devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于蒙特卡洛树搜索思想的中国象棋AI-C++实现

作者：Monodyee | 2024-05-23 10:48:10

赞

踩

基于蒙特卡洛树搜索思想的中国象棋AI-C++实现
  1. /*象棋ai*/
  2. #pragma GCC optimize(1)
  3. #pragma GCC optimize(2)
  4. #pragma GCC optimize(3)
  5. #pragma GCC optimize("Ofast")
  6. #pragma GCC optimize("inline")
  7. #pragma GCC optimize("-fgcse")
  8. #pragma GCC optimize("-fgcse-lm")
  9. #pragma GCC optimize("-fipa-sra")
  10. #pragma GCC optimize("-ftree-pre")
  11. #pragma GCC optimize("-ftree-vrp")
  12. #pragma GCC optimize("-fpeephole2")
  13. #pragma GCC optimize("-ffast-math")
  14. #pragma GCC optimize("-fsched-spec")
  15. #pragma GCC optimize("unroll-loops")
  16. #pragma GCC optimize("-falign-jumps")
  17. #pragma GCC optimize("-falign-loops")
  18. #pragma GCC optimize("-falign-labels")
  19. #pragma GCC optimize("-fdevirtualize")
  20. #pragma GCC optimize("-fcaller-saves")
  21. #pragma GCC optimize("-fcrossjumping")
  22. #pragma GCC optimize("-fthread-jumps")
  23. #pragma GCC optimize("-funroll-loops")
  24. #pragma GCC optimize("-freorder-blocks")
  25. #pragma GCC optimize("-fschedule-insns")
  26. #pragma GCC optimize("inline-functions")
  27. #pragma GCC optimize("-ftree-tail-merge")
  28. #pragma GCC optimize("-fschedule-insns2")
  29. #pragma GCC optimize("-fstrict-aliasing")
  30. #pragma GCC optimize("-falign-functions")
  31. #pragma GCC optimize("-fcse-follow-jumps")
  32. #pragma GCC optimize("-fsched-interblock")
  33. #pragma GCC optimize("-fpartial-inlining")
  34. #pragma GCC optimize("no-stack-protector")
  35. #pragma GCC optimize("-freorder-functions")
  36. #pragma GCC optimize("-findirect-inlining")
  37. #pragma GCC optimize("-fhoist-adjacent-loads")
  38. #pragma GCC optimize("-frerun-cse-after-loop")
  39. #pragma GCC optimize("inline-small-functions")
  40. #pragma GCC optimize("-finline-small-functions")
  41. #pragma GCC optimize("-ftree-switch-conversion")
  42. #pragma GCC optimize("-foptimize-sibling-calls")
  43. #pragma GCC optimize("-fexpensive-optimizations")
  44. #pragma GCC optimize("inline-functions-called-once")
  45. #pragma GCC optimize("-fdelete-null-pointer-checks")
  46. #include<bits/stdc++.h>
  47. #include<random>
  48. #include<ctime>
  49. #include<windows.h>
  50. #include<omp.h>
  51. #define pll pair<int,int>
  52. using namespace std;
  53. typedef double lf;
  54. const int N=3e6;
  55. static default_random_engine e;
  56. struct Chess {
  57.     int des[10][9];
  58. };
  59. int maxnumcore;
  60. int maxstep=6;
  61. int maxcal=5000;
  62. int thinktime=100;
  63. int nodelimt=6;
  64. int siz=0;
  65. vector<int> datree[N];
  66. Chess chess[N];
  67. int fa[N],dep[N],mark[N],endpo[N],roval[N],del[N];
  68. lf n[N],w[N],winrate[N];
  69.  
  70. int qzw[32] = { -100,-3,-3,-3,-3,-7,-7,-15,-15,-10,-10,-1,-1,-1,-1,-1,100,3,3,3,3,7,7,15,15,10,10,1,1,1,1,1 };
  71. pair<int, int> limx[16] = { {0,2},{0,2},{0,2},{0,4},{0,4},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9}};
  72. pair<int, int> limy[16] = { {3,5},{3,5},{3,5},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8}};
  73. Chess prec;
  74. class cheess{
  75. public:
  76.     lf c = 2;
  77.     pair<int, int> POS[32];
  78.     Chess base;
  79.     inline int calval(Chess&u){
  80.         int cn=0;
  81.         for(int i=0;i<10;i++)for(int j=0;j<9;j++)
  82.             if(u.des[i][j]>=0)cn+=qzw[u.des[i][j]];
  83.         return cn;
  84.     }
  85.     void init() {
  86.         POS[0] = { 0,4 }; POS[1] = { 0,3 }; POS[2] = { 0,5 }; POS[3] = { 0,2 }; POS[4] = { 0,6 };
  87.         POS[5] = { 0,1 }; POS[6] = { 0,7 }; POS[7] = { 0,0 }; POS[8] = { 0,8 }; POS[9] = { 2,1 };
  88.         POS[10] = { 2,7 }; POS[11] = { 3,0 }; POS[12] = { 3,2 }; POS[13] = { 3,4 }; POS[14] = { 3,6 };
  89.         POS[15] = { 3,8 }; POS[16] = { 9,4 }; POS[17] = { 9,5 }; POS[18] = { 9,3 }; POS[19] = { 9,6 };
  90.         POS[20] = { 9,2 }; POS[21] = { 9,7 }; POS[22] = { 9,1 }; POS[23] = { 9,8 }; POS[24] = { 9,0 };
  91.         POS[25] = { 7,7 }; POS[26] = { 7,1 }; POS[31] = { 6,0 }; POS[30] = { 6,2 }; POS[29] = { 6,4 };
  92.         POS[28] = { 6,6 }; POS[27] = { 6,8 };
  93.         for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++)base.des[i][j] = -1;
  94.         for (int i = 0; i < 32; i++) base.des[POS[i].first][POS[i].second] = i;
  95.         //base.des[6][0]=base.des[6][2]=base.des[6][4]=base.des[6][6]=base.des[6][8]=-1;
  96.         //base.des[3][0]=base.des[3][2]=base.des[3][4]=base.des[3][6]=base.des[3][8]=-1;
  97.     }
  98.         inline int Checkend(Chess &u){//查看是否结局
  99.         int x=1;
  100.         for(int i=limx[0].first;i<=limx[0].second;i++)
  101.             for(int j=limy[0].first;j<=limy[0].second;j++)
  102.                 if(u.des[i][j]==0)x=0;
  103.         return x;
  104.     }
  105.     inline Chess rev(Chess& a) {//局面旋转
  106.         Chess k;
  107.         for(int i=0;i<10;i++)for(int j=0;j<9;j++)k.des[i][j]=-1;
  108.         for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++){
  109.             if(a.des[9 - i][8 - j]>15)k.des[i][j] = a.des[9 - i][8 - j]-16;
  110.             else if(a.des[9 - i][8 - j]>=0)k.des[i][j] = a.des[9 - i][8 - j]+16;
  111.         }
  112.         return k;
  113.     }
  114.     inline Chess Creatdes(int posxi, int posyi, int posx, int posy, Chess p) {//根据走子建立新局面
  115.         int i = p.des[posxi][posyi];
  116.         p.des[posx][posy] = i;
  117.         p.des[posxi][posyi] = -1;
  118.         return rev(p);
  119.     }
  120.     inline void creatnode(int u,Chess&son) {//建立节点
  121.         int k=++siz;
  122.         datree[u].push_back(k);
  123.         datree[k].clear();
  124.         fa[k]=u;
  125.         chess[k]=son;
  126.         w[k]=n[k]=winrate[k]=0;
  127.         dep[k]=dep[u] + 1;
  128.         mark[k]=!mark[u];
  129.         endpo[k]=roval[k]=del[k]=0;
  130.     }
  131.     inline int judge(Chess& u, int i, int posx, int posy) {
  132.         if (i == 0 && u.des[posx][posy] == 16)return 1;
  133.         if (!(limx[i].first <= posx && posx <= limx[i].second && limy[i].first <= posy && posy <= limy[i].second))return 0;
  134.         if (!(u.des[posx][posy] == -1 || u.des[posx][posy] > 15))return 0;
  135.         return 1;
  136.     }
  137.     void newrate(int u) {
  138.         winrate[u] = w[u] / (n[u]*100) + (lf)c * sqrt(max(log(n[fa[u]]) / n[u],0.0));
  139.     }
  140.     inline vector<Chess> step(Chess tmp, int sw) {//在tmp的局面里面获取走子可能，sw为1获取所有能
  141.         pair<int, int> poi[32];
  142.         for (int i = 0; i < 32; i++)poi[i] = { -1,-1 };
  143.         for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++)if (tmp.des[i][j] >= 0)poi[tmp.des[i][j]] = { i,j };
  144.         vector<Chess> ans;
  145.  
  146.         int nposx, nposy, posx, posy;
  147.         auto work = [&](int i)-> void {
  148.             if (judge(tmp, i, nposx, nposy))
  149.                 ans.push_back(Creatdes(posx, posy, nposx, nposy, tmp));
  150.         };
  151.         for (int i = 0; i <= 15; i++) {
  152.             if(sw==0)i=e()%16;
  153.             if (poi[i].first == -1)continue;
  154.             posx = poi[i].first, posy = poi[i].second;
  155.             if (i == 0) {
  156.                 nposx = posx - 1, nposy = posy;
  157.                 work(i);
  158.                 nposx = posx + 1, nposy = posy;
  159.                 work(i);
  160.                 nposx = posx, nposy = posy + 1;
  161.                 work(i);
  162.                 nposx = posx, nposy = posy - 1;
  163.                 work(i);
  164.                 if (posy == poi[16].second) {
  165.                     nposx = poi[16].first, nposy = poi[16].second;
  166.                     int x=0;
  167.                     for(int j=posx+1;j<=nposx-1;j++)if(tmp.des[j][posy]!=-1)x=1;
  168.                     if(x==0){
  169.                         work(i);
  170.                         
  171.                     }
  172.                 }
  173.             }
  174.             else if (i == 1 || i == 2) {
  175.                 nposx = posx - 1, nposy = posy - 1;
  176.                 work(i);
  177.                 nposx = posx + 1, nposy = posy + 1;
  178.                 work(i);
  179.                 nposx = posx - 1, nposy = posy + 1;
  180.                 work(i);
  181.                 nposx = posx + 1, nposy = posy - 1;
  182.                 work(i);
  183.             }
  184.             else if (i == 3 || i == 4) {
  185.                 if (posx - 1 >= 0 && posy - 1 >= 0 && tmp.des[posx - 1][posy - 1] == -1) {
  186.                     nposx = posx - 2, nposy = posy - 2;
  187.                     work(i);
  188.                 }
  189.                 if (posx + 1 <= 9 && posy + 1 <= 8 && tmp.des[posx + 1][posy + 1] == -1) {
  190.                     nposx = posx + 2, nposy = posy + 2;
  191.                     work(i);
  192.                 }
  193.                 if (posx + 1 <= 9 && posy - 1 >= 0 && tmp.des[posx + 1][posy - 1] == -1) {
  194.                     nposx = posx + 2, nposy = posy - 2;
  195.                     work(i);
  196.                 }
  197.                 if (posx - 1 >= 0 && posy + 1 <= 8 && tmp.des[posx - 1][posy + 1] == -1) {
  198.                     nposx = posx - 2, nposy = posy + 2;
  199.                     work(i);
  200.                 }
  201.             }
  202.             else if (i == 5 || i == 6) {
  203.                 if (posx - 1 >= 0 && tmp.des[posx - 1][posy] == -1) {
  204.                     nposx = posx - 2, nposy = posy - 1;
  205.                     work(i);
  206.                     nposx = posx - 2, nposy = posy + 1;
  207.                     work(i);
  208.                 }
  209.                 if (posx + 1 <= 9 && tmp.des[posx + 1][posy] == -1) {
  210.                     nposx = posx + 2, nposy = posy + 1;
  211.                     work(i);
  212.                     nposx = posx + 2, nposy = posy - 1;
  213.                     work(i);
  214.                 }
  215.                 if (posy - 1 >= 0 && tmp.des[posx][posy - 1] == -1) {
  216.                     nposx = posx - 1, nposy = posy - 2;
  217.                     work(i);
  218.                     nposx = posx + 1, nposy = posy - 2;
  219.                     work(i);
  220.                 }
  221.                 if (posy + 1 <= 8 && tmp.des[posx][posy + 1] == -1) {
  222.                     nposx = posx - 1, nposy = posy + 2;
  223.                     work(i);
  224.                     nposx = posx + 1, nposy = posy + 2;
  225.                     work(i);
  226.                 }
  227.             }
  228.             else if (i == 7 || i == 8) {
  229.                 for (int j = 1; j <= 9; j++) {
  230.                     nposx = posx + j, nposy = posy;
  231.                     work(i);
  232.                     if (posx + j > 9 || tmp.des[posx + j][posy] != -1)break;
  233.                 }
  234.                 for (int j = 1; j <= 9; j++) {
  235.                     nposx = posx - j, nposy = posy;
  236.                     work(i);
  237.                     if (posx - j < 0 || tmp.des[posx - j][posy] != -1)break;
  238.                 }
  239.                 for (int j = 1; j <= 8; j++) {
  240.                     nposx = posx, nposy = posy + j;
  241.                     work(i);
  242.                     if (posy + j > 8 || tmp.des[posx][posy + j] != -1)break;
  243.                 }
  244.                 for (int j = 1; j <= 8; j++) {
  245.                     nposx = posx, nposy = posy - j;
  246.                     work(i);
  247.                     if (posy - j < 0 || tmp.des[posx][posy - j] != -1)break;
  248.                 }
  249.             }
  250.             else if (i == 9 || i == 10) {
  251.                 for (int j = 1; j <= 9; j++) {
  252.                     if (posx + j > 9)break;
  253.                     if (tmp.des[posx + j][posy] == -1) {
  254.                         nposx = posx + j, nposy = posy;
  255.                         work(i);
  256.                     }
  257.                     if (tmp.des[posx + j][posy] != -1) {
  258.                         j++;
  259.                         while (posx + j <= 9 && tmp.des[posx + j][posy] == -1)j++;
  260.                         nposx = posx + j, nposy = posy;
  261.                         work(i);
  262.                         break;
  263.                     }
  264.                 }
  265.                 for (int j = 1; j <= 9; j++) {
  266.                     if (posx - j < 0)break;
  267.                     if (tmp.des[posx - j][posy] == -1) {
  268.                         nposx = posx - j, nposy = posy;
  269.                         work(i);
  270.                     }
  271.                     if (tmp.des[posx - j][posy] != -1) {
  272.                         j++;
  273.                         while (posx - j >= 0 && tmp.des[posx - j][posy] == -1)j++;
  274.                         nposx = posx - j, nposy = posy;
  275.                         work(i);
  276.                         break;
  277.                     }
  278.                 }
  279.                 for (int j = 1; j <= 8; j++) {
  280.                     if (posy + j > 8)break;
  281.                     if (tmp.des[posx][posy + j] == -1) {
  282.                         nposx = posx, nposy = posy + j;
  283.                         work(i);
  284.                     }
  285.                     if (tmp.des[posx][posy + j] != -1) {
  286.                         j++;
  287.                         while (posy + j <= 8 && tmp.des[posx][posy + j] == -1)j++;
  288.                         nposx = posx, nposy = posy + j;
  289.                         work(i);
  290.                         break;
  291.                     }
  292.                 }
  293.                 for (int j = 1; j <= 8; j++) {
  294.                     if (posy - j < 0)break;
  295.                     if (tmp.des[posx][posy - j] == -1) {
  296.                         nposx = posx, nposy = posy - j;
  297.                         work(i);
  298.                     }
  299.                     if (tmp.des[posx][posy - j] != -1) {
  300.                         j++;
  301.                         while (posy - j >= 0 && tmp.des[posx][posy - j] == -1)j++;
  302.                         nposx = posx, nposy = posy - j;
  303.                         work(i);
  304.                         break;
  305.                     }
  306.                 }
  307.             }
  308.             else {
  309.                 nposx = posx + 1, nposy = posy;
  310.                 work(i);
  311.                 if (posx > 4) {
  312.                     nposx = posx, nposy = posy + 1;
  313.                     work(i);
  314.                     nposx = posx, nposy = posy - 1;
  315.                     work(i);
  316.                 }
  317.             }
  318.             if(sw==0&&ans.size())return ans;
  319.         }
  320.         return ans;
  321.     }
  322.  
  323.     int rollout(Chess u,int dep) {
  324.         int ans = 0;
  325.         if (Checkend(u)) {
  326.             return 1e9;
  327.         }
  328.         for (int tp = 1; tp <= thinktime; tp++) {
  329.             auto tmp = u;
  330.             int cnt = maxstep - dep;
  331.             int lun=1;
  332.             while (cnt>=0) {
  333.                 vector<Chess> mulp;
  334.                 while(mulp.size()<1)mulp=step(tmp,0);
  335.                 int fe = 1;
  336.                 lun=!lun;
  337.                 for (auto& v : mulp) {
  338.                     if(!Checkend(v))continue;
  339.                     if (lun==0)ans -= calval(v);
  340.                     else ans+=calval(v);
  341.                     fe=0;
  342.                 }
  343.                 if(fe==0)break;
  344.                 random_shuffle(mulp.begin(), mulp.end());
  345.                 tmp=mulp.back();
  346.                 cnt--;
  347.                 if(cnt<0){
  348.                     if (lun==0)ans -= calval(tmp);
  349.                     else ans+= calval(tmp);
  350.                 }
  351.             }
  352.         }
  353.         return ans;
  354.     }
  355.     void creat(int u) {
  356.         auto p=step(chess[u],1);
  357.         vector<pll> snf(p.size());
  358. #pragma omp parallel for num_threads(maxnumcore)
  359.         for(int i=0;i<p.size();i++){
  360.             auto&v=p[i];
  361.             snf[i]={rollout(v,dep[u]+1),i};
  362.         }
  363.         sort(snf.begin(), snf.end(), greater<pll>());
  364.         for(int i=0;i<nodelimt&&i<snf.size();i++)
  365.             creatnode(u,p[snf[i].second]);
  366.  
  367.     }
  368.     int explor(int u) {
  369.         if (datree[u].empty())creat(u);
  370.         vector<pair<lf,int>> snf;
  371.         for (auto& v : datree[u]) {
  372.             if (!n[v])snf.push_back({ roval[v]+1e8,v });
  373.             else newrate(v),snf.push_back({ winrate[v],v });
  374.         }
  375.         sort(snf.begin(), snf.end());
  376.         return snf.back().second;
  377.     }
  378.     void spreadback(int end) {
  379.         lf cn = 0;
  380.         int v = end;
  381.         while (v != 0) {
  382.             n[v]++;
  383.             if (mark[v] == mark[end])cn+=calval(chess[v]);
  384.             else cn-=calval(chess[v]);
  385.             if (mark[v] == mark[end])w[v] += cn;
  386.             else w[v] -= cn;
  387.             newrate(v);
  388.             v = fa[v];
  389.         }
  390.     }
  391.     inline void sendmessage(int rx,int ry,int px,int py){
  392.         ofstream outFile;
  393.         outFile.open("rec.txt", std::ios::out);
  394. 		outFile << rx<<' '<<ry<<'\n';
  395.         outFile << px<<' '<<py<<'\n';
  396. 		outFile.close();
  397.         outFile.open("message.txt", std::ios::out);
  398.         outFile<<1<<'\n';
  399.         outFile.close();
  400.     }
  401.     Chess cal(Chess u) {
  402.         siz=0;
  403.         chess[0]=u; datree[0].clear();
  404.         n[0]=w[0]=winrate[0]=0;
  405.         fa[0]=-1; dep[0]=mark[0]=endpo[0]=roval[0]=del[0]=0;
  406.         int cnt=0,root=0;
  407.         while (1) {
  408.             cout<< siz <<"\n";
  409.             cout << cnt <<"\n";
  410.             root = explor(root);
  411.             cnt++;
  412.             if (cnt>= maxcal)break;
  413.             if (endpo[root] || cnt>= maxcal) {
  414.                 spreadback(root);
  415.                 root = 0;
  416.                 if (cnt>= maxcal)break;
  417.                 continue;
  418.             }
  419.             else if (dep[root] > maxstep || cnt>= maxcal) {
  420.                 spreadback(root);
  421.                 root = 0;
  422.                 if (cnt>= maxcal)break;
  423.                 continue;
  424.             }
  425.             if (cnt>= maxcal)break;
  426.         }
  427.         Chess ans;
  428.         lf maxr = -1e9;
  429.         for (auto& v : datree[0]) {
  430.             if (n[v] == 0)continue;
  431.             newrate(v);
  432.             if (w[v]/n[v] > maxr) {
  433.                 maxr = w[v]/n[v];
  434.                 ans = chess[v];
  435.             }
  436.         }
  437.         return ans;
  438.     }
  439.     void cp() {
  440.         Chess now=base,tmp;
  441.         prec=base;
  442.         while (1) {
  443.             tmp=now;
  444.             now = cal(now);
  445.             prec=tmp;
  446.             tmp=rev(now);
  447.  
  448.             int readx,ready,px,py;
  449.             for(int i=0;i<10;i++)for(int j=0;j<9;j++)if(prec.des[i][j]!=tmp.des[i][j]){
  450.                 if(tmp.des[i][j]!=-1){
  451.                     px=i,py=j;
  452.                 }
  453.                 else readx=i,ready=j;
  454.             }
  455.             
  456.             sendmessage(readx,ready,px,py);
  457.  
  458.             if(Checkend(now)){
  459.                 cout<<"ERO!!!!!!!!!!!!\n";
  460.                 system("pause");
  461.                 break;
  462.             }
  463.             
  464.             tmp=now;
  465.             now = cal(now);
  466.             prec=rev(tmp);
  467.             
  468.             tmp=now;
  469.  
  470.             for(int i=0;i<10;i++)for(int j=0;j<9;j++)if(prec.des[i][j]!=tmp.des[i][j]){
  471.                 if(tmp.des[i][j]!=-1){
  472.                     px=i,py=j;
  473.                 }
  474.                 else readx=i,ready=j;
  475.             }
  476.             sendmessage(readx,ready,px,py);
  477.             if(Checkend(now)){
  478.                 cout<<"ERO!!!!!!!!!!!!\n";
  479.                 system("pause");
  480.                 break;
  481.             }
  482.         }
  483.     }
  484. }tester;
  485. int main()
  486. {
  487.     maxnumcore = omp_get_num_procs();
  488.     tester.init();
  489.     e.seed(time(0));
  490.     while (1) {
  491.         tester.cp();
  492.     }
  493.     while(1);
  494.     return 0;
  495. }
  1. /*棋盘easyx实现*/
  2. // includes
  3. #include<iostream>
  4. #include<graphics.h>
  5. #include<bits/stdc++.h>
  6. using namespace std;
  7.  
  8. // 使用到的 WCHAR 字符
  9. class CKind {
  10. public:
  11. 	WCHAR ROOKS = *(_T("车"));
  12. 	WCHAR KNIGHTS = *_T("马");
  13. 	WCHAR ELEPHANTS = *_T("象");
  14. 	WCHAR MINISTERS = *_T("相");
  15. 	WCHAR MANDARINS = *_T("士");
  16. 	WCHAR GUARDS = *_T("仕");
  17. 	WCHAR KING = *_T("将");
  18. 	WCHAR GENERALS = *_T("帅");
  19. 	WCHAR CANNONS = *_T("炮");
  20. 	WCHAR PAWNS = *_T("卒");
  21. 	WCHAR SOLDIERS = *_T("兵");
  22. 	WCHAR PLAYER_1 = *_T("BLACK");
  23. 	WCHAR PLAYER_2 = *_T("RED");
  24. };
  25.  
  26. // 落子点
  27. class Grid {
  28. 	int x, y;
  29. public:
  30. 	Grid() {};
  31. 	virtual WCHAR get_name() { return NULL; }
  32. 	virtual void drowReady(int x, int y) {}
  33. 	virtual void setPlayer(WCHAR player) {}
  34. 	virtual WCHAR getPlayer() { return NULL; }
  35. 	void set_xy(int x, int y)
  36. 	{
  37. 		this->x = x;
  38. 		this->y = y;
  39. 	}
  40. 	pair<int, int>get_xy()
  41. 	{
  42. 		pair<int, int>p(x, y);
  43. 		return p;
  44. 	}
  45. };
  46.  
  47. // 棋子
  48. class Chess :public Grid
  49. {
  50. 	WCHAR player;
  51. 	WCHAR name;
  52. public:
  53. 	Chess(WCHAR name)
  54. 	{
  55. 		this->name = name;
  56. 	}
  57. 	WCHAR get_name()
  58. 	{
  59. 		return name;
  60. 	}
  61. 	void setPlayer(WCHAR player)
  62. 	{
  63. 		this->player = player;
  64. 	}
  65. 	WCHAR getPlayer()
  66. 	{
  67. 		return player;
  68. 	}
  69. 	void drowReady(int x, int y)
  70. 	{
  71. 		setfillcolor(RGB(51, 205, 219));
  72. 		fillcircle(x, y, 27);
  73. 		RECT r = { x - 18, y - 18, x + 18, y + 18 };
  74. 		setbkcolor(RGB(51, 205, 219));
  75. 		if (player == *_T("BLACK"))
  76. 		{
  77. 			settextcolor(BLACK);
  78. 		}
  79. 		else
  80. 			settextcolor(RED);
  81. 		drawtext(name, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  82. 	}
  83. };
  84.  
  85. // 棋盘
  86. class PaneBoard {
  87. 	CKind ckind;
  88. 	int PERLENGTH;//单位长度
  89. 	Grid* grid[10][9];
  90. public:
  91. 	PaneBoard()
  92. 	{
  93. 		PERLENGTH = 60;
  94. 	}
  95. 	//开始游戏
  96. 	void startGame()
  97. 	{
  98. 		initPaneGrid();
  99. 		CreateMap();
  100. 		repaint();
  101. 		messagewhile();
  102. 		closegraph();
  103. 	}
  104. 	//初始化棋盘格
  105. 	void initPaneGrid()
  106. 	{
  107. 		for (int i = 0; i < 9; i++)
  108. 		{
  109. 			for (int j = 0; j < 10; j++)
  110. 			{
  111. 				grid[i][j] = NULL;
  112. 			}
  113. 		}
  114. 		//敌方
  115. 		grid[0][0] = new Chess(ckind.ROOKS);
  116. 		grid[0][1] = new Chess(ckind.KNIGHTS);
  117. 		grid[0][2] = new Chess(ckind.ELEPHANTS);
  118. 		grid[0][3] = new Chess(ckind.MANDARINS);
  119. 		grid[0][4] = new Chess(ckind.KING);
  120. 		grid[0][5] = new Chess(ckind.MANDARINS);
  121. 		grid[0][6] = new Chess(ckind.ELEPHANTS);
  122. 		grid[0][7] = new Chess(ckind.KNIGHTS);
  123. 		grid[0][8] = new Chess(ckind.ROOKS);
  124. 		grid[2][1] = new Chess(ckind.CANNONS);
  125. 		grid[2][7] = new Chess(ckind.CANNONS);
  126. 		for (int i = 0; i <= 8; i += 2)
  127. 		{
  128. 			grid[3][i] = new Chess(ckind.PAWNS);
  129. 		}
  130. 		//设置棋盘格坐标与属性
  131. 		for (int j = 0; j <= 8; j++)
  132. 		{
  133. 			grid[0][j]->set_xy(PERLENGTH * (j + 1), PERLENGTH);
  134. 			grid[0][j]->setPlayer(ckind.PLAYER_1);
  135. 		}
  136. 		grid[2][1]->set_xy(2 * PERLENGTH, 3 * PERLENGTH);
  137. 		grid[2][7]->set_xy(8 * PERLENGTH, 3 * PERLENGTH);
  138. 		grid[2][1]->setPlayer(ckind.PLAYER_1);
  139. 		grid[2][7]->setPlayer(ckind.PLAYER_1);
  140. 		for (int i = 0; i <= 8; i += 2)
  141. 		{
  142. 			grid[3][i]->set_xy((i + 1) * PERLENGTH, 4 * PERLENGTH);
  143. 			grid[3][i]->setPlayer(ckind.PLAYER_1);
  144. 		}
  145. 		//我方
  146. 		grid[9][0] = new Chess(ckind.ROOKS);
  147. 		grid[9][1] = new Chess(ckind.KNIGHTS);
  148. 		grid[9][2] = new Chess(ckind.MINISTERS);
  149. 		grid[9][3] = new Chess(ckind.GUARDS);
  150. 		grid[9][4] = new Chess(ckind.GENERALS);
  151. 		grid[9][5] = new Chess(ckind.GUARDS);
  152. 		grid[9][6] = new Chess(ckind.MINISTERS);
  153. 		grid[9][7] = new Chess(ckind.KNIGHTS);
  154. 		grid[9][8] = new Chess(ckind.ROOKS);
  155. 		grid[7][1] = new Chess(ckind.CANNONS);
  156. 		grid[7][7] = new Chess(ckind.CANNONS);
  157. 		for (int i = 0; i <= 8; i += 2)
  158. 		{
  159. 			grid[6][i] = new Chess(ckind.SOLDIERS);
  160. 		}
  161. 		//设置棋盘格坐标与属性
  162. 		for (int j = 0; j <= 8; j++)
  163. 		{
  164. 			grid[9][j]->set_xy(PERLENGTH * (j + 1), 10 * PERLENGTH);
  165. 			grid[9][j]->setPlayer(ckind.PLAYER_2);
  166. 		}
  167. 		grid[7][1]->set_xy(2 * PERLENGTH, 8 * PERLENGTH);
  168. 		grid[7][7]->set_xy(8 * PERLENGTH, 8 * PERLENGTH);
  169. 		grid[7][1]->setPlayer(ckind.PLAYER_2);
  170. 		grid[7][7]->setPlayer(ckind.PLAYER_2);
  171. 		for (int i = 0; i <= 8; i += 2)
  172. 		{
  173. 			grid[6][i]->set_xy((i + 1) * PERLENGTH, 7 * PERLENGTH);
  174. 			grid[6][i]->setPlayer(ckind.PLAYER_2);
  175. 		}
  176. 	}
  177. 	//创建窗口
  178. 	void CreateMap()
  179. 	{
  180. 		initgraph(10 * PERLENGTH, 11 * PERLENGTH);//单位宽度
  181. 		setbkcolor(WHITE);
  182. 		cleardevice();
  183. 	}
  184.  
  185. 	//重绘棋盘
  186. 	void repaint()
  187. 	{
  188. 		setbkcolor(WHITE);
  189. 		cleardevice();
  190. 		setlinecolor(BLACK);
  191. 		setlinestyle(PS_SOLID | PS_JOIN_BEVEL, 3);
  192. 		line(PERLENGTH - 5, PERLENGTH - 5, PERLENGTH * 9 + 5, PERLENGTH - 5);
  193. 		line(PERLENGTH - 5, PERLENGTH - 5, PERLENGTH - 5, PERLENGTH * 10 + 5);
  194. 		line(PERLENGTH - 5, PERLENGTH * 10 + 5, PERLENGTH * 9 + 5, PERLENGTH * 10 + 5);
  195. 		line(PERLENGTH * 9 + 5, PERLENGTH * 10 + 5, PERLENGTH * 9 + 5, PERLENGTH - 5);
  196. 		setlinestyle(PS_SOLID | PS_JOIN_BEVEL, 2);
  197. 		for (int i = 1; i <= 10; i++)
  198. 		{
  199. 			line(PERLENGTH, i * PERLENGTH, 9 * PERLENGTH, i * PERLENGTH);
  200. 		}
  201. 		for (int i = 1; i <= 9; i++)
  202. 		{
  203. 			line(i * PERLENGTH, PERLENGTH, i * PERLENGTH, 5 * PERLENGTH);
  204. 			line(i * PERLENGTH, 6 * PERLENGTH, i * PERLENGTH, 10 * PERLENGTH);
  205. 		}
  206. 		line(PERLENGTH, 5 * PERLENGTH, PERLENGTH, 6 * PERLENGTH);
  207. 		line(9 * PERLENGTH, 5 * PERLENGTH, 9 * PERLENGTH, 6 * PERLENGTH);
  208. 		line(4 * PERLENGTH, PERLENGTH, 6 * PERLENGTH, 3 * PERLENGTH);
  209. 		line(4 * PERLENGTH, 3 * PERLENGTH, 6 * PERLENGTH, PERLENGTH);
  210. 		line(4 * PERLENGTH, 8 * PERLENGTH, 6 * PERLENGTH, 10 * PERLENGTH);
  211. 		line(4 * PERLENGTH, 10 * PERLENGTH, 6 * PERLENGTH, 8 * PERLENGTH);
  212. 		settextcolor(RED);
  213. 		settextstyle(PERLENGTH * 2 / 3, 0, _T("楷体"));
  214. 		RECT r = { 2 * PERLENGTH, 5 * PERLENGTH, 4 * PERLENGTH, 6 * PERLENGTH };
  215. 		drawtext(_T("楚河"), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  216. 		r = { 6 * PERLENGTH, 5 * PERLENGTH, 8 * PERLENGTH, 6 * PERLENGTH };
  217. 		drawtext(_T("汉界"), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  218. 		for (int i = 3; i <= 7; i += 2)
  219. 		{
  220. 			//敌方
  221. 			line(i * PERLENGTH - 3, 4 * PERLENGTH - 3, i * PERLENGTH - 3, 4 * PERLENGTH - 10);
  222. 			line(i * PERLENGTH - 3, 4 * PERLENGTH - 3, i * PERLENGTH - 10, 4 * PERLENGTH - 3);
  223. 			line(i * PERLENGTH - 3, 4 * PERLENGTH + 3, i * PERLENGTH - 3, 4 * PERLENGTH + 10);
  224. 			line(i * PERLENGTH - 3, 4 * PERLENGTH + 3, i * PERLENGTH - 10, 4 * PERLENGTH + 3);
  225. 			line(i * PERLENGTH + 3, 4 * PERLENGTH - 3, i * PERLENGTH + 3, 4 * PERLENGTH - 10);
  226. 			line(i * PERLENGTH + 3, 4 * PERLENGTH - 3, i * PERLENGTH + 10, 4 * PERLENGTH - 3);
  227. 			line(i * PERLENGTH + 3, 4 * PERLENGTH + 3, i * PERLENGTH + 3, 4 * PERLENGTH + 10);
  228. 			line(i * PERLENGTH + 3, 4 * PERLENGTH + 3, i * PERLENGTH + 10, 4 * PERLENGTH + 3);
  229. 			//我方
  230. 			line(i * PERLENGTH - 3, 7 * PERLENGTH - 3, i * PERLENGTH - 3, 7 * PERLENGTH - 10);
  231. 			line(i * PERLENGTH - 3, 7 * PERLENGTH - 3, i * PERLENGTH - 10, 7 * PERLENGTH - 3);
  232. 			line(i * PERLENGTH - 3, 7 * PERLENGTH + 3, i * PERLENGTH - 3, 7 * PERLENGTH + 10);
  233. 			line(i * PERLENGTH - 3, 7 * PERLENGTH + 3, i * PERLENGTH - 10, 7 * PERLENGTH + 3);
  234. 			line(i * PERLENGTH + 3, 7 * PERLENGTH - 3, i * PERLENGTH + 3, 7 * PERLENGTH - 10);
  235. 			line(i * PERLENGTH + 3, 7 * PERLENGTH - 3, i * PERLENGTH + 10, 7 * PERLENGTH - 3);
  236. 			line(i * PERLENGTH + 3, 7 * PERLENGTH + 3, i * PERLENGTH + 3, 7 * PERLENGTH + 10);
  237. 			line(i * PERLENGTH + 3, 7 * PERLENGTH + 3, i * PERLENGTH + 10, 7 * PERLENGTH + 3);
  238. 		}
  239. 		for (int i = 2; i <= 8; i += 6)
  240. 			for (int j = 3; j <= 8; j += 5)
  241. 			{
  242. 				line(i * PERLENGTH - 3, j * PERLENGTH - 3, i * PERLENGTH - 3, j * PERLENGTH - 10);
  243. 				line(i * PERLENGTH - 3, j * PERLENGTH - 3, i * PERLENGTH - 10, j * PERLENGTH - 3);
  244. 				line(i * PERLENGTH - 3, j * PERLENGTH + 3, i * PERLENGTH - 3, j * PERLENGTH + 10);
  245. 				line(i * PERLENGTH - 3, j * PERLENGTH + 3, i * PERLENGTH - 10, j * PERLENGTH + 3);
  246. 				line(i * PERLENGTH + 3, j * PERLENGTH - 3, i * PERLENGTH + 3, j * PERLENGTH - 10);
  247. 				line(i * PERLENGTH + 3, j * PERLENGTH - 3, i * PERLENGTH + 10, j * PERLENGTH - 3);
  248. 				line(i * PERLENGTH + 3, j * PERLENGTH + 3, i * PERLENGTH + 3, j * PERLENGTH + 10);
  249. 				line(i * PERLENGTH + 3, j * PERLENGTH + 3, i * PERLENGTH + 10, j * PERLENGTH + 3);
  250. 			}
  251. 		for (int j = 4; j <= 7; j += 3)
  252. 		{
  253. 			line(PERLENGTH + 3, j * PERLENGTH - 3, PERLENGTH + 3, j * PERLENGTH - 10);
  254. 			line(PERLENGTH + 3, j * PERLENGTH - 3, PERLENGTH + 10, j * PERLENGTH - 3);
  255. 			line(PERLENGTH + 3, j * PERLENGTH + 3, PERLENGTH + 3, j * PERLENGTH + 10);
  256. 			line(PERLENGTH + 3, j * PERLENGTH + 3, PERLENGTH + 10, j * PERLENGTH + 3);
  257. 		}
  258. 		for (int j = 4; j <= 7; j += 3)
  259. 		{
  260. 			line(9 * PERLENGTH - 3, j * PERLENGTH - 3, 9 * PERLENGTH - 3, j * PERLENGTH - 10);
  261. 			line(9 * PERLENGTH - 3, j * PERLENGTH - 3, 9 * PERLENGTH - 10, j * PERLENGTH - 3);
  262. 			line(9 * PERLENGTH - 3, j * PERLENGTH + 3, 9 * PERLENGTH - 3, j * PERLENGTH + 10);
  263. 			line(9 * PERLENGTH - 3, j * PERLENGTH + 3, 9 * PERLENGTH - 10, j * PERLENGTH + 3);
  264. 		}
  265. 		for (int i = 0; i < 10; i++)
  266. 		{
  267. 			for (int j = 0; j < 9; j++)
  268. 			{
  269. 				if (grid[i][j] != NULL)
  270. 				{
  271. 					pair<int, int>p = grid[i][j]->get_xy();
  272. 					int x = p.first; int y = p.second;
  273. 					setfillcolor(RGB(200, 220, 250));
  274. 					setbkcolor(RGB(200, 220, 250));
  275. 					fillcircle(x, y, 27);
  276. 					RECT r = { x - 18, y - 18, x + 18, y + 18 };
  277. 					if (grid[i][j]->getPlayer() == *_T("BLACK"))
  278. 					{
  279. 						settextcolor(BLACK);
  280. 					}
  281. 					else
  282. 						settextcolor(RED);
  283. 					drawtext(grid[i][j]->get_name(), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  284. 				}
  285. 			}
  286. 		}
  287. 	}
  288.  
  289. 	//进入消息循环
  290. 	void messagewhile()
  291. 	{
  292. 		MOUSEMSG msg;
  293. 		pair<int, int>p;
  294. 		pair<int, int>readyChess;
  295. 		while (1) {
  296. 			ifstream data("message.txt", std::ios::in);
  297. 			int mm;
  298. 			data >> mm;
  299. 			if (mm != 1) {
  300. 				data.close();
  301. 				continue;
  302. 			}
  303. 			data.close();
  304.  
  305. 			ofstream outFile;
  306. 			outFile.open("message.txt", std::ios::out);
  307. 			outFile << 0<<'\n';
  308. 			outFile.close();
  309.  
  310. 			ifstream rec("rec.txt", std::ios::in);
  311. 			rec >> readyChess.first;
  312. 			rec >> readyChess.second;
  313. 			rec >> p.first;
  314. 			rec >> p.second;
  315.  
  316. 			grid[p.first][p.second] = grid[readyChess.first][readyChess.second];
  317. 			pair<int, int>change = compute_xy(p.first, p.second);
  318. 			grid[p.first][p.second]->set_xy(change.first, change.second);
  319. 			grid[readyChess.first][readyChess.second] = NULL;
  320.  
  321. 			repaint();
  322. 			rec.close();
  323. 			continue;
  324. 		}
  325. 	}
  326. 	pair<int, int>compute_xy(int i, int j)
  327. 	{
  328. 		pair<int, int>p((j + 1) * PERLENGTH, (i + 1) * PERLENGTH);
  329. 		return p;
  330. 	}
  331. };
  332. void main()
  333. {
  334. 	PaneBoard paneBoard;
  335. 	paneBoard.startGame();
  336. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/612498
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号