HTML5 利用canvas构建 Web五子棋游戏程序设计

 
这只是一个简单的javascript和HTML5小程序，没有实现人机对战。
 
五子棋棋盘落子点对应的二维数组。数组的元素对应落子点。比如数组元素值为0表示该元素对应的落子点没有棋子，数组元素值为1表示该元素对应的落子点有白棋子，数组元素值为2表示该元素对应的落子点有黑棋子；
 
 判断五子棋赢棋的算法是通过对五子棋棋盘落子点对应的二维数组的操作来实现的。
 
 
 
 判断五子棋赢棋算法
 
下边的函数可以实现判断五子棋赢棋的算法，也可以按照教材中相应的算法实现。
 
其中函数的参数xx.yy为数组下标，chess数组实现五子棋棋盘落子点的数据结构映射。
 
算法的思想方法是：以当前落子点对应的下标为基点，向其周围8个方向进行搜索，如果有同色子连五子，返回1，或2，否则返回0。返回1代表白棋方胜，返回2代表黑棋方胜。返回0代表没有发生赢棋数据结构状态。
 
 
 
提供程序用到的棋子
 

 

 

 
    
     
         
  1. <!DOCTYPE html> 
    2.  
         
  2. <html xmlns="http://www.w3.org/1999/xhtml"> 
    3.  
         
  3. <head> 
    4.  
         
  4.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
    5.  
         
  5.     <title></title> 
    6.  
         
  6.     <style type="text/css"> 
    7.  
         
  7.         body { 
    8.  
         
  8.             margin: 10px; 
    9.  
         
  9.         } 
    10.  
         
  10.     </style> 
    11.  
         
  11.     <script type="text/javascript"> 
    12.  
         
  12.         var canvas; 
    13.  
         
  13.         var context; 
    14.  
         
  14.         var isWhite = true;//设置是否该轮到白棋 
    15.  
         
  15.         var isWell = false;//设置该局棋盘是否赢了，如果赢了就不能再走了 
    16.  
         
  16.         var img_b = new Image(); 
    17.  
         
  17.         img_b.src = "p_w_picpaths/b.png";//白棋图片 
    18.  
         
  18.         var img_w = new Image(); 
    19.  
         
  19.         img_w.src = "p_w_picpaths/w.png";//黑棋图片 
    20.  
         
  20.   
    21.  
         
  21.         var chessData = new Array(15);//这个为棋盘的二维数组用来保存棋盘信息，初始化0为没有走过的，1为白棋走的，2为黑棋走的 
    22.  
         
  22.         for (var x = 0; x < 15; x++) { 
    23.  
         
  23.             chessData[x] = new Array(15); 
    24.  
         
  24.             for (var y = 0; y < 15; y++) { 
    25.  
         
  25.                 chessData[x][y] = 0; 
    26.  
         
  26.             } 
    27.  
         
  27.         } 
    28.  
         
  28.   
    29.  
         
  29.         function drawRect() {//页面加载完毕调用函数，初始化棋盘 
    30.  
         
  30.             canvas = document.getElementById("canvas"); 
    31.  
         
  31.             context = canvas.getContext("2d"); 
    32.  
         
  32.   
    33.  
         
  33.             for (var i = 0; i <= 640; i += 40) {//绘制棋盘的线 
    34.  
         
  34.                 context.beginPath(); 
    35.  
         
  35.                 context.moveTo(0, i); 
    36.  
         
  36.                 context.lineTo(640, i); 
    37.  
         
  37.                 context.closePath(); 
    38.  
         
  38.                 context.stroke(); 
    39.  
         
  39.   
    40.  
         
  40.                 context.beginPath(); 
    41.  
         
  41.                 context.moveTo(i, 0); 
    42.  
         
  42.                 context.lineTo(i, 640); 
    43.  
         
  43.                 context.closePath(); 
    44.  
         
  44.                 context.stroke(); 
    45.  
         
  45.             } 
    46.  
         
  46.         } 
    47.  
         
  47.         function play(e) {//鼠标点击时发生 
    48.  
         
  48.             var x = parseInt((e.clientX - 20) / 40);//计算鼠标点击的区域，如果点击了（65，65），那么就是点击了（1，1）的位置 
    49.  
         
  49.             var y = parseInt((e.clientY - 20) / 40); 
    50.  
         
  50.   
    51.  
         
  51.             if (chessData[x][y] != 0) {//判断该位置是否被下过了 
    52.  
         
  52.                 alert("你不能在这个位置下棋"); 
    53.  
         
  53.                 return; 
    54.  
         
  54.             } 
    55.  
         
  55.   
    56.  
         
  56.             if (isWhite) { 
    57.  
         
  57.                 isWhite = false; 
    58.  
         
  58.                 drawChess(1, x, y); 
    59.  
         
  59.             } 
    60.  
         
  60.             else { 
    61.  
         
  61.                 isWhite = true; 
    62.  
         
  62.                 drawChess(2, x, y); 
    63.  
         
  63.             } 
    64.  
         
  64.   
    65.  
         
  65.         } 
    66.  
         
  66.         function drawChess(chess, x, y) {//参数为，棋（1为白棋，2为黑棋），数组位置 
    67.  
         
  67.             if (isWell == true) { 
    68.  
         
  68.                 alert("已经结束了，如果需要重新玩，请刷新"); 
    69.  
         
  69.                 return; 
    70.  
         
  70.             } 
    71.  
         
  71.             if (x >= 0 && x < 15 && y >= 0 && y < 15) { 
    72.  
         
  72.                 if (chess == 1) { 
    73.  
         
  73.                     context.drawImage(img_w, x * 40 + 20, y * 40 + 20);//绘制白棋 
    74.  
         
  74.                     chessData[x][y] = 1; 
    75.  
         
  75.                 } 
    76.  
         
  76.                 else { 
    77.  
         
  77.                     context.drawImage(img_b, x * 40 + 20, y * 40 + 20); 
    78.  
         
  78.                     chessData[x][y] = 2; 
    79.  
         
  79.                 } 
    80.  
         
  80.                 judge(x, y, chess); 
    81.  
         
  81.             } 
    82.  
         
  82.         } 
    83.  
         
  83.         function judge(x, y, chess) {//判断该局棋盘是否赢了 
    84.  
         
  84.             var count1 = 0; 
    85.  
         
  85.             var count2 = 0; 
    86.  
         
  86.             var count3 = 0; 
    87.  
         
  87.             var count4 = 0; 
    88.  
         
  88.   
    89.  
         
  89.             //左右判断 
    90.  
         
  90.             for (var i = x; i >= 0; i--) { 
    91.  
         
  91.                 if (chessData[i][y] != chess) { 
    92.  
         
  92.                     break; 
    93.  
         
  93.                 } 
    94.  
         
  94.                 count1++; 
    95.  
         
  95.             } 
    96.  
         
  96.             for (var i = x + 1; i < 15; i++) { 
    97.  
         
  97.                 if (chessData[i][y] != chess) { 
    98.  
         
  98.                     break; 
    99.  
         
  99.                 } 
    100.  
         
  100.                 count1++; 
    101.  
         
  101.             } 
    102.  
         
  102.             //上下判断 
    103.  
         
  103.             for (var i = y; i >= 0; i--) { 
    104.  
         
  104.                 if (chessData[x][i] != chess) { 
    105.  
         
  105.                     break; 
    106.  
         
  106.                 } 
    107.  
         
  107.                 count2++; 
    108.  
         
  108.             } 
    109.  
         
  109.             for (var i = y + 1; i < 15; i++) { 
    110.  
         
  110.                 if (chessData[x][i] != chess) { 
    111.  
         
  111.                     break; 
    112.  
         
  112.                 } 
    113.  
         
  113.                 count2++; 
    114.  
         
  114.             } 
    115.  
         
  115.             //左上右下判断 
    116.  
         
  116.             for (var i = x, j = y; i >= 0, j >= 0; i--, j--) { 
    117.  
         
  117.                 if (chessData[i][j] != chess) { 
    118.  
         
  118.                     break; 
    119.  
         
  119.                 } 
    120.  
         
  120.                 count3++; 
    121.  
         
  121.             } 
    122.  
         
  122.             for (var i = x + 1, j = y + 1; i < 15, j < 15; i++, j++) { 
    123.  
         
  123.                 if (chessData[i][j] != chess) { 
    124.  
         
  124.                     break; 
    125.  
         
  125.                 } 
    126.  
         
  126.                 count3++; 
    127.  
         
  127.             } 
    128.  
         
  128.             //右上左下判断 
    129.  
         
  129.             for (var i = x, j = y; i >= 0, j < 15; i--, j++) { 
    130.  
         
  130.                 if (chessData[i][j] != chess) { 
    131.  
         
  131.                     break; 
    132.  
         
  132.                 } 
    133.  
         
  133.                 count4++; 
    134.  
         
  134.             } 
    135.  
         
  135.             for (var i = x + 1, j = y - 1; i < 15, j >= 0; i++, j--) { 
    136.  
         
  136.                 if (chessData[i][j] != chess) { 
    137.  
         
  137.                     break; 
    138.  
         
  138.                 } 
    139.  
         
  139.                 count4++; 
    140.  
         
  140.             } 
    141.  
         
  141.   
    142.  
         
  142.             if (count1 >= 5 || count2 >= 5 || count3 >= 5 || count4 >= 5) { 
    143.  
         
  143.                 if (chess == 1) { 
    144.  
         
  144.                     alert("白棋赢了"); 
    145.  
         
  145.                 } 
    146.  
         
  146.                 else { 
    147.  
         
  147.                     alert("黑棋赢了"); 
    148.  
         
  148.                 } 
    149.  
         
  149.                 isWell = true;//设置该局棋盘已经赢了，不可以再走了 
    150.  
         
  150.             } 
    151.  
         
  151.         } 
    152.  
         
  152.     </script> 
    153.  
         
  153. </head> 
    154.  
         
  154. <body onload="drawRect()"> 
    155.  
         
  155.     <div> 
    156.  
         
  156.         <canvas width="640" id="canvas" onmousedown="play(event)" height="640">你的浏览器不支持HTML5 canvas  ，请使用 google chrome 浏览器 打开. 
    157.  
         
  157.         </canvas> 
    158.  
         
  158.     </div> 
    159.  
         
  159.   
    160.  
         
  160. </body> 
    161.  
         
  161. </html> 
    162.