原生 JS + Canvas 实现五子棋游戏

Posted SegmentFault

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了原生 JS + Canvas 实现五子棋游戏相关的知识,希望对你有一定的参考价值。

一、功能模块

先看下现在做完的效果:

线上体验:

https://wj704.github.io/five_game.html

主要功能模块为:

  1. 人机对战功能 

  2. 悔棋功能 

  3. 撤销悔棋功能

二、代码详解

2.1 人机对战功能实现

从效果图可以看到,棋盘的横竖可以放的位置为15*15,通过canvas画棋盘:

 
   
   
 
  1.        //绘画棋盘

  2.        var drawChessBoard = function(){

  3.            for(var i = 0; i < 15; i++){

  4.                context.moveTo(15 + i * 30 , 15);

  5.                context.lineTo(15 + i * 30 , 435);

  6.                context.stroke();

  7.                context.moveTo(15 , 15 + i * 30);

  8.                context.lineTo(435 , 15 + i * 30);

  9.                context.stroke();

  10.            }

  11.        }

知道格子数后,我们先看五子棋有多少种赢法:

 
   
   
 
  1.             //赢法数组

  2.            var wins = [];

  3.            for(var i = 0; i < 15; i++){

  4.                wins[i] = [];

  5.                for(var j = 0; j < 15; j++){

  6.                    wins[i][j] = [];

  7.                }

  8.            }

  9.            var count = 0; //赢法总数

  10.            //横线赢法

  11.            for(var i = 0; i < 15; i++){

  12.                for(var j = 0; j < 11; j++){

  13.                    for(var k = 0; k < 5; k++){

  14.                        wins[i][j+k][count] = true;

  15.                    }

  16.                    count++;

  17.                }

  18.            }

  19.            //竖线赢法

  20.            for(var i = 0; i < 15; i++){

  21.                for(var j = 0; j < 11; j++){

  22.                    for(var k = 0; k < 5; k++){

  23.                        wins[j+k][i][count] = true;

  24.                    }

  25.                    count++;

  26.                }

  27.            }

  28.            //正斜线赢法

  29.            for(var i = 0; i < 11; i++){

  30.                for(var j = 0; j < 11; j++){

  31.                    for(var k = 0; k < 5; k++){

  32.                        wins[i+k][j+k][count] = true;

  33.                    }

  34.                    count++;

  35.                }

  36.            }

  37.            //反斜线赢法

  38.            for(var i = 0; i < 11; i++){

  39.                for(var j = 14; j > 3; j--){

  40.                    for(var k = 0; k < 5; k++){

  41.                        wins[i+k][j-k][count] = true;

  42.                    }

  43.                    count++;

  44.                }

  45.            }

根据赢法总数定义分别保存计算机和人赢法的数组:

 
   
   
 
  1.    for(var i = 0; i < count; i++){

  2.                myWin[i] = 0;

  3.                _myWin[i] = 0;

  4.                computerWin[i] = 0;

  5.                _compWin[i] = 0;

  6.     }

然后就是人开始下棋:

 
   
   
 
  1.    // 我,下棋

  2.    chess.onclick = function(e){

  3.        if(over){ // 游戏结束

  4.            return;

  5.        }

  6.        if(!me){

  7.            return;

  8.        }

  9.        var x = e.offsetX;

  10.        var y = e.offsetY;

  11.        var i = Math.floor(x / 30);

  12.        var j = Math.floor(y / 30);

  13.        _nowi = i;

  14.        _nowj = j;

  15.        if(chressBord[i][j] == 0){

  16.            oneStep(i,j,me);

  17.            chressBord[i][j] = 1; //我,已占位置        

  18.            for(var k = 0; k < count; k++){ // 将可能赢的情况都加1

  19.                if(wins[i][j][k]){

  20.                    myWin[k]++;

  21.                    _compWin[k] = computerWin[k]; // 为悔棋做准备

  22.                    computerWin[k] = 6;//这个位置对方不可能赢了

  23.                    if(myWin[k] == 5){

  24.                        resultTxt.innerHTML = '恭喜,你赢了!';

  25.                        over = true;

  26.                    }

  27.                }

  28.            }

  29.            if(!over){

  30.                me = !me;

  31.                computerAI();

  32.            }

  33.        }

  34.        // 悔棋功能可用

  35.        backbtn.className = backbtn.className.replace( new RegExp( "(\\s|^)unable(\\s|$)" )," " );          

  36.    }

oneStep() 方法为落子,要在棋盘上画一个棋子:

 
   
   
 
  1.        //画棋子

  2.        var oneStep = function(i,j,me){

  3.            // debugger;

  4.            context.beginPath();

  5.            context.arc(15 + i * 30, 15 + j * 30, 13, 0, 2 * Math.PI);//画圆

  6.            context.closePath();

  7.            //渐变

  8.            var gradient = context.createRadialGradient(15 + i * 30 + 2, 15 + j * 30 - 2, 13, 15 + i * 30 + 2, 15 + j * 30 - 2, 0);

  9.            if(me){

  10.                gradient.addColorStop(0,'#0a0a0a');

  11.                gradient.addColorStop(1,'#636766');

  12.            }else{

  13.                gradient.addColorStop(0,'#d1d1d1');

  14.                gradient.addColorStop(1,'#f9f9f9');

  15.            }

  16.            context.fillStyle = gradient;

  17.            context.fill();

  18.        }

接着看计算机怎么下棋,具体看computerAI()方法:

 
   
   
 
  1.        // 计算机下棋

  2.        var computerAI = function (){

  3.            var myScore = [];

  4.            var computerScore = [];

  5.            var max = 0;

  6.            var u = 0, v = 0;

  7.            for(var i = 0; i < 15; i++){

  8.                myScore[i] = [];

  9.                computerScore[i] = [];

  10.                for(var j = 0; j < 15; j++){

  11.                    myScore[i][j] = 0;

  12.                    computerScore[i][j] = 0;

  13.                }

  14.            }

  15.            for(var i = 0; i < 15; i++){

  16.                for(var j = 0; j < 15; j++){

  17.                    if(chressBord[i][j] == 0){

  18.                        for(var k = 0; k < count; k++){

  19.                            if(wins[i][j][k]){

  20.                                if(myWin[k] == 1){

  21.                                    myScore[i][j] += 200;

  22.                                }else if(myWin[k] == 2){

  23.                                    myScore[i][j] += 400;

  24.                                }else if(myWin[k] == 3){

  25.                                    myScore[i][j] += 2000;

  26.                                }else if(myWin[k] == 4){

  27.                                    myScore[i][j] += 10000;

  28.                                }

  29.                                if(computerWin[k] == 1){

  30.                                    computerScore[i][j] += 220;

  31.                                }else if(computerWin[k] == 2){

  32.                                    computerScore[i][j] += 420;

  33.                                }else if(computerWin[k] == 3){

  34.                                    computerScore[i][j] += 2100;

  35.                                }else if(computerWin[k] == 4){

  36.                                    computerScore[i][j] += 20000;

  37.                                }                        

  38.                            }

  39.                        }

  40.                        if(myScore[i][j] > max){

  41.                            max  = myScore[i][j];

  42.                            u = i;

  43.                            v = j;

  44.                        }else if(myScore[i][j] == max){

  45.                            if(computerScore[i][j] > computerScore[u][v]){

  46.                                u = i;

  47.                                v = j;    

  48.                            }

  49.                        }

  50.                        if(computerScore[i][j] > max){

  51.                            max  = computerScore[i][j];

  52.                            u = i;

  53.                            v = j;

  54.                        }else if(computerScore[i][j] == max){

  55.                            if(myScore[i][j] > myScore[u][v]){

  56.                                u = i;

  57.                                v = j;    

  58.                            }

  59.                        }

  60.                    }

  61.                }

  62.            }

  63.            _compi = u;

  64.            _compj = v;

  65.            oneStep(u,v,false);

  66.            chressBord[u][v] = 2;  //计算机占据位置

  67.            for(var k = 0; k < count; k++){

  68.                if(wins[u][v][k]){

  69.                    computerWin[k]++;

  70.                    _myWin[k] = myWin[k];

  71.                    myWin[k] = 6;//这个位置对方不可能赢了

  72.                    if(computerWin[k] == 5){

  73.                        resultTxt.innerHTML = 'o(╯□╰)o,计算机赢了,继续加油哦!';

  74.                        over = true;

  75.                    }

  76.                }

  77.            }

  78.            if(!over){

  79.                me = !me;

  80.            }

  81.        }

根据相应的权重,计算出计算机应该落子的位置。

2.2 悔棋功能

要提的是,这里暂时只能悔一步棋。悔棋功能主要关键点是:1、销毁刚刚下的棋子;2、将之前不可能赢的状态还原;看下具体的代码:

 
   
   
 
  1.            // 悔棋

  2.            backbtn.onclick = function(e){

  3.                if(!backAble) { return;}

  4.                over = false;

  5.                me = true;

  6.                // 我,悔棋

  7.                chressBord[_nowi][_nowj] = 0; //我,已占位置 还原

  8.                minusStep(_nowi, _nowj); //销毁棋子                                  

  9.                for(var k = 0; k < count; k++){ // 将可能赢的情况都减1

  10.                    if(wins[_nowi][_nowj][k]){

  11.                        myWin[k]--;

  12.                        computerWin[k] = _compWin[k];//这个位置对方可能赢

  13.                    }

  14.                }

  15.                // 计算机相应的悔棋

  16.                chressBord[_compi][_compj] = 0; //计算机,已占位置 还原

  17.                minusStep(_compi, _compj); //销毁棋子                                  

  18.                for(var k = 0; k < count; k++){ // 将可能赢的情况都减1

  19.                    if(wins[_compi][_compj][k]){

  20.                        computerWin[k]--;

  21.                        myWin[k] = _myWin[i];//这个位置对方可能赢

  22.                    }

  23.                }

  24.                resultTxt.innerHTML = '--益智五子棋--';

  25.                returnAble = true;

  26.                backAble = false;

  27.                 // 撤销悔棋功能可用

  28.                returnbtn.className = returnbtn.className.replace( new RegExp( "(\\s|^)unable(\\s|$)" )," " );

  29.            }

minusStep()为销毁棋子的方法,我们看下是怎么销毁的。

 
   
   
 
  1.         //销毁棋子

  2.         var minusStep = function(i,j) {

  3.            //擦除该圆

  4.            context.clearRect((i) * 30, (j) * 30, 30, 30);

  5.            // 重画该圆周围的格子

  6.            context.beginPath();

  7.            context.moveTo(15+i*30 , j*30);

  8.            context.lineTo(15+i*30 , j*30 + 30);

  9.            context.moveTo(i*30, j*30+15);

  10.            context.lineTo((i+1)*30 , j*30+15);

  11.            context.stroke();

  12.        }

首先通过clearRect()擦掉该圆,然后再重新画该圆周围的格子,注意相应的位置,这里花了些时间折腾。

2.3 撤销悔棋功能

悔棋过后,再撤销,相当于还原悔棋之前的状态。代码比较简单:

 
   
   
 
  1.        // 撤销悔棋

  2.        returnbtn.onclick = function(e){

  3.            if(!returnAble) { return; }

  4.            // 我,撤销悔棋

  5.            chressBord[_nowi][_nowj] = 1; //我,已占位置

  6.            oneStep(_nowi,_nowj,me);                              

  7.            for(var k = 0; k < count; k++){

  8.                if(wins[_nowi][_nowj][k]){

  9.                    myWin[k]++;

  10.                    _compWin[k] = computerWin[k];

  11.                    computerWin[k] = 6;//这个位置对方不可能赢

  12.                }

  13.                if(myWin[k] == 5){          

  14.                    resultTxt.innerHTML = '恭喜,你赢了!';

  15.                    over = true;

  16.                }

  17.            }

  18.            // 计算机撤销相应的悔棋

  19.            chressBord[_compi][_compj] = 2; //计算机,已占位置  

  20.            oneStep(_compi,_compj,false);                              

  21.            for(var k = 0; k < count; k++){

  22.                if(wins[_compi][_compj][k]){

  23.                    computerWin[k]++;

  24.                    _myWin[k] = myWin[k];

  25.                    myWin[k] = 6;//这个位置对方不可能赢

  26.                }

  27.                if(computerWin[k] == 5){

  28.                    resultTxt.innerHTML = 'o(╯□╰)o,计算机赢了,继续加油哦!';

  29.                    over = true;

  30.                }

  31.            }

  32.            returnbtn.className += 'unable';

  33.            returnAble = false;

  34.            backAble = true;

  35.        }

至此,比较简单的完成了这三个功能。

三、总结

五子棋游戏的核心关键点是:

1、弄清楚有多少种赢法;

2、怎么判断是否已经赢了;

3、计算机下棋算法。这里巧妙地运用数组存储赢法,判断是否赢了,通过权重比较,计算出计算机该下棋的位置。 过程中用到canvas,之前有学习过,虽然很久没用,查了些资料,复习了怎么画线,画圆,学会了怎么如何清除一个圆等。 然后要注意的是,用原生Js怎么为元素添加、删除class。 最后代码放到github上了,

https://github.com/wj704/wj704.github.io/blob/master/five_game.html

参考资料:

http://www.cnblogs.com/gdcgy/p/5379159.html


以上是关于原生 JS + Canvas 实现五子棋游戏的主要内容,如果未能解决你的问题,请参考以下文章

原生 JS + Canvas 实现五子棋游戏

原生 JS + Canvas 实现五子棋游戏

用原生js+canvas实现五子棋

VUE+Canvas实现简单的五子棋游戏

前端开发趣味之五子棋小游戏(JS+Node+Websocket)可分房间对战

js小游戏:五子棋