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

2分钟自己写小游戏：使用js和css编写石头剪刀布小游戏、扫雷小游戏、五子棋小游戏。新手老手毕业论文都能用。

作者：小小林熬夜学编程 | 2024-05-03 01:38:02

赞

踩

2分钟自己写小游戏：使用js和css编写石头剪刀布小游戏、扫雷小游戏、五子棋小游戏。新手老手毕业论文都能用。

系列文章目录

【复制就能用1】2分钟玩转轮播图,unslider的详细用法

【复制就能用2】css实现转动的大风车，效果很不错。

【复制就能用3】2分钟自己写小游戏：剪刀石头布小游戏、扫雷游戏、五子棋小游戏

【复制就能用4】2024最新智慧医疗智慧医院大数据展示，医院数据采集概况等，源代码免费下载

【复制就能用5】99成纯干货：2024年十套电商交通气象可视化大屏模板，免积分下载打开即可运行

        随着大家对程序员职业的深入，可能大多都越来越喜欢复制就能用的代码，能让我们完成工作任务，早点下班。同时也能更快的学习。所以本着不浪费时间的理念，打算多分享有意思，高效的代码，且发布前经过测试，尽量不会有BUG的。欢迎大家关注交流。

一、扫雷小游戏

1、话不多说，先看效果

2、扫雷源代码

  1. <!doctype html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <title>扫雷游戏</title>
  6. <script src="https://libs.baidu.com/jquery/1.11.3/jquery.min.js"></script>
  7. <style>
  8. #stage {
  9. 	margin:0 auto;
  10. 	border-left:1px solid #666;
  11. 	border-top:1px solid #666;
  12. 	vertical-align:middle;
  13. 	text-align:center;
  14. }
  15. .lv1 {
  16. 	width:300px;
  17. 	height:300px;
  18. }
  19. .lv2 {
  20. 	width:480px;
  21. 	height:480px;
  22. }
  23. .lv3 {
  24. 	width:900px;
  25. 	height:480px;
  26. }
  27. .map > div {
  28. 	background-color:#ccc;
  29. 	float:left;
  30. }
  31. .wait {
  32. 	width:22px;
  33. 	height:22px;
  34. 	border:4px solid #888;
  35. 	border-top-color:#fff;
  36. 	border-left-color:#FFF;
  37. }
  38. .clear {
  39. 	width:29px;
  40. 	height:29px;
  41. 	border-right:1px solid #888;
  42. 	border-bottom:1px solid #888;
  43. 	line-height:29px;
  44. 	font-size:18px;
  45. 	font-weight:bold;
  46. }
  47. </style>
  48. </head>
  49. <body>
  50.  
  51.  
  52. <script>
  53. document.write('<div id="stage" class="map"></div>');
  54. var map = document.getElementById("stage");
  55. var mines = [];
  56. var rn = []; //-11,9,-1,-10,10,1,-9,11];
  57. var fc = ["", "#3866A4", "#067d16", "#980505", "#061b5a", "#5e0404"];
  58. var sn = 0;
  59.  
  60. var lv1 = {
  61.     classname: "lv1",
  62.     col: 10,
  63.     row: 10,
  64.     mns: 10,
  65.     sum: 100
  66. }
  67. var lv2 = {
  68.     classname: "lv2",
  69.     col: 16,
  70.     row: 16,
  71.     mns: 40,
  72.     sum: 256
  73. }
  74. var lv3 = {
  75.     classname: "lv3",
  76.     col: 16,
  77.     row: 30,
  78.     mns: 100,
  79.     sum: 16 * 30
  80. }
  81. var lv;
  82.  
  83. function setLevel(level) {
  84.     switch (level) {
  85.         case "2":
  86.             lv = lv2;
  87.             break;
  88.         case "3":
  89.             lv = lv3;
  90.             break;
  91.         case "1":
  92.         default:
  93.             lv = lv1;
  94.     }
  95.     map.classList.add(lv.classname);
  96.     rn = [-lv.row - 1, lv.row - 1, -1, -lv.row, lv.row, 1, -lv.row + 1, lv.row + 1];
  97. }
  98.  
  99. function newGame() {
  100.     sn = 0;
  101.     var ms = []
  102.     for (var i = 0; i < lv.sum; i++) {
  103.         mines[i] = 0;
  104.         ms[i] = i;
  105.     }
  106.     for (var i = 0; i < lv.mns; i++) {
  107.         var r = parseInt(Math.random() * ms.length);
  108.         mr = ms[r];
  109.         ms.splice(r, 1);
  110.         mines[mr] = -1;
  111.         for (var j = 0; j < rn.length; j++) {
  112.             var n = mr + rn[j]
  113.             if (mines[n] != -1 && n >= 0 && n < lv.sum && !((mr % lv.row == 0) && (j < 3) || (mr % lv.row == lv.row - 1) && (j > 4))) mines[n]++;
  114.         }
  115.     }
  116.     for (var i = 0; i < lv.sum; i++) mines[i] = mines[i] == 0 ? "" : mines[i];
  117. }
  118. // 绘制地图
  119. function paintMap() {
  120.     var str = "";
  121.     for (var i = 0; i < lv.sum; i++)
  122.         //str += '<div id="mine'+i+'" onclick="sweepe('+i+')" class="wait">'+mines[i]+'</div>';
  123.         str += '<div id="mine' + i + '" onclick="sweepe(' + i + ')" class="wait"></div>';
  124.     map.innerHTML += str;
  125. }
  126.  
  127. function sweepe(i) {
  128.     var m = document.getElementById("mine" + i);
  129.     if (!m || m.className == "clear") return;
  130.     m.className = "clear";
  131.     m.innerHTML = mines[i];
  132.     m.style.color = fc[mines[i]];
  133.     sn++;
  134.     if (mines[i] == -1) alert("Lose!!");
  135.     else if (mines[i] == 0)
  136.         for (var j = 0; j < 8; j++) {
  137.             var n = i + rn[j];
  138.             if (n >= 0 && n < lv.sum && (!((i % lv.row == 0) && (j < 3) || (i % lv.row == lv.row - 1) && (j > 4)))) sweepe(n);
  139.         }
  140.     else {
  141.         for (var j = 0; j < 8; j++) {
  142.             var n = i + rn[j];
  143.             if (n >= 0 && n < lv.sum && (!((i % lv.row == 0) && (j < 3) || (i % lv.row == lv.row - 1) && (j > 4))))
  144.                 if (mines[n] == 0) sweepe(n);
  145.         }
  146.     }
  147.     if (sn == lv.sum - lv.mns) alert("Win!!");
  148. }
  149. setLevel(prompt("请输入等级（1-3）："));
  150. newGame();
  151. paintMap();
  152. </script>
  153.  
  154. </body>
  155. </html>

3、源代码讲解

扫雷游戏：扫雷游戏的源代码主要包括游戏初始化、雷区生成、用户输入处理、开格逻辑和胜负判断等部分。在初始化阶段，会设定游戏区域和地雷数量。接着，随机生成地雷位置并标记。用户输入时，代码会判断点击的方格是否为雷，非雷则递归展开周围的安全区域。最终，通过判断所有非雷区域是否都已展开，来确定游戏胜负。源代码结构清晰，逻辑严谨，是游戏开发的经典案例。

二、石头剪刀布小游戏

1、先看效果

2、石头剪刀布游戏源代码

  1. <!doctype html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <title>石头剪刀布游戏</title>
  6. <script src="https://libs.baidu.com/jquery/1.11.3/jquery.min.js"></script>
  7. <style>
  8. #main {
  9. 	width:260px;
  10. 	height:480px;
  11. 	margin:auto;
  12. 	text-indent:15px;
  13. 	font-size:1.6em;
  14. }
  15. #top {
  16. 	width:100%;
  17. 	height:230px;
  18. 	background-color:#C8CAB1;
  19. 	border:2px solid #0C80DC;
  20. }
  21. #you,#pc {
  22. 	color:red;
  23. }
  24. #mid {
  25. 	width:100%;
  26. 	height:110px;
  27. 	background-color:#C8CAB1;
  28. 	margin-top:30px;
  29. 	border:2px solid #0C80DC;
  30. }
  31. #result {
  32. 	width:100%;
  33. 	height:80px;
  34. 	background-color:#C8CAB1;
  35. 	margin-top:30px;
  36. 	color:red;
  37. 	border:2px solid #0C80DC;
  38. }
  39. #btn {
  40. 	width:80px;
  41. 	height:25px;
  42. 	margin-top:30px;
  43. 	display:none;
  44. }
  45. #s,#t,#b {
  46. 	display:block;
  47. 	margin-top:30px;
  48. 	margin-left:15px;
  49. }
  50. </style>
  51. </head>
  52. <body>
  53. <div id="main">
  54.     <div id="top">你出什么？
  55.         <span id="you">请选择</span>
  56.         <button id="s">石头</button>
  57.         <button id="t">抹布</button>
  58.         <button id="b">剪子</button>
  59.     </div>
  60.     <div id="mid">电脑出？
  61.         <div id="pc"></div>
  62.     </div>
  63.     <div id="result"></div>
  64.     <button id="btn">再来一次</button>
  65. </div>
  66.  
  67. <script>
  68. function $(aName) {
  69.     return document.getElementById(aName);
  70. }
  71.  
  72. var you = $('you'),
  73.     oTop = $('top'),
  74.     s = $('s'),
  75.     t = $('t'),
  76.     b = $('b'),
  77.     pc = $('pc'),
  78.     btn = $('btn'),
  79.     result = $('result');
  80.  
  81. var time = 25;
  82. var btns = oTop.getElementsByTagName('button');
  83.  
  84. function stb(n) {
  85.     if (n == 1) {
  86.         return '石头';
  87.     } else if (n == 2) {
  88.         return '抹布';
  89.     } else {
  90.         return '剪刀';
  91.     }
  92. }
  93.  
  94. for (var i = 0; i < btns.length; i++) {
  95.     btns[i].index = i;
  96.     btns[i].onclick = function function_name() {
  97.         for (var i = 0; i < btns.length; i++) {
  98.             btns[i].disabled = true;
  99.         }
  100.         var n = this.index + 1;
  101.         you.innerHTML = stb(this.index + 1);
  102.         result.innerHTML = '...';
  103.  
  104.         function pct() {
  105.             if (time > 0) {
  106.                 var num = parseInt(Math.random() * (3 - 1 + 1) + 1);
  107.                 pc.innerHTML = stb(num);
  108.                 time--;
  109.             } else {
  110.                 clearInterval(timerN);
  111.                 timerN = null;
  112.                 time = 25;
  113.             }
  114.         }
  115.  
  116.  
  117.  
  118.         var timer = setTimeout(function() {
  119.             //						var num=setInterval(pct,20);
  120.  
  121.             var num = parseInt(Math.random() * (3 - 1 + 1) + 1);
  122.             pc.innerHTML = stb(num);
  123.  
  124.             if (num == n) {
  125.                 result.innerHTML = '平局';
  126.                 btn.style.display = 'block';
  127.             } else {
  128.                 if (num - n > 0) {
  129.  
  130.                     if (num - n == 1) {
  131.                         result.innerHTML = '你输了';
  132.                         btn.style.display = 'block';
  133.                     } else {
  134.                         result.innerHTML = '你赢啦';
  135.                         btn.style.display = 'block';
  136.                     }
  137.                 } else {
  138.                     if (num - n == -1) {
  139.                         result.innerHTML = '你赢啦';
  140.                         btn.style.display = 'block';
  141.                     } else {
  142.                         result.innerHTML = '你输了';
  143.                         btn.style.display = 'block';
  144.                     }
  145.                 }
  146.             }
  147.  
  148.         }, 600);
  149.  
  150.     }
  151. }
  152.  
  153.  
  154.  
  155. btn.onclick = function() {
  156.     you.innerHTML = '请选择';
  157.     pc.innerHTML = '';
  158.     result.innerHTML = '';
  159.     btn.style.display = 'none';
  160.  
  161.     for (var i = 0; i < btns.length; i++) {
  162.         btns[i].disabled = false;
  163.     }
  164. }
  165. </script>
  166.  
  167. </body>
  168. </html>

3、石头剪刀布小游戏源代码讲解

剪刀石布游戏：剪刀石布游戏源代码的核心逻辑在于通过函数随机生成计算机的选择，然后通过input函数获取用户的选择。接着，代码通过一系列的条件判断语句来比较用户和计算机的选择，最终输出胜负结果。整个代码逻辑简单明了，易于理解，是实现剪刀石布游戏的基本框架。

三、五子棋小游戏

1、游戏效果

2、五子棋小游戏源代码

  1. <!doctype html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <title>五子棋游戏</title>
  6. <script src="https://libs.baidu.com/jquery/2.1.4/jquery.min.js"></script>
  7. <style>
  8. canvas {
  9. 	display:block;
  10. 	margin:50px auto;
  11. 	box-shadow:-2px -2px 2px #efefef,5px 5px 5px #b9b9b9;
  12. 	cursor:pointer;
  13. }
  14. .btn-wrap {
  15. 	display:flex;
  16. 	flex-direction:row;
  17. 	justify-content:center;
  18. }
  19. .btn-wrap div {
  20. 	margin:0 10px;
  21. }
  22. div>span {
  23. 	display:inline-block;
  24. 	padding:10px 20px;
  25. 	color:#fff;
  26. 	background-color:#EE82EE;
  27. 	border-radius:5px;
  28. 	cursor:pointer;
  29. }
  30. div.unable span {
  31. 	background:#D6D6D4;
  32. 	color:#adacaa;
  33. }
  34. #result-wrap {
  35. 	text-align:center;
  36. }
  37. </style>
  38. </head>
  39. <body>
  40. <h3 id="result-wrap">--益智五子棋--</h3>
  41. <canvas id="chess" width="450px" height="450px"></canvas>
  42. <div class="btn-wrap">
  43.     <div id="restart" class="restart">
  44.         <span>重新开始</span>
  45.     </div>
  46.     <div id="goback" class="goback unable">
  47.         <span>悔棋</span>
  48.     </div>
  49.     <div id="return" class="return unable">
  50.         <span>撤销悔棋</span>
  51.     </div>
  52. </div>
  53.  
  54. <script>
  55. var over = false;
  56. var me = true; //我 
  57. var _nowi = 0,
  58.     _nowj = 0; //记录自己下棋的坐标 
  59. var _compi = 0,
  60.     _compj = 0; //记录计算机当前下棋的坐标 
  61. var _myWin = [],
  62.     _compWin = []; //记录我，计算机赢的情况 
  63. var backAble = false,
  64.     returnAble = false;
  65. var resultTxt = document.getElementById('result-wrap');
  66. var chressBord = []; //棋盘 
  67. for (var i = 0; i < 15; i++) {
  68.     chressBord[i] = [];
  69.     for (var j = 0; j < 15; j++) {
  70.         chressBord[i][j] = 0;
  71.     }
  72. }
  73. //赢法的统计数组 
  74. var myWin = [];
  75. var computerWin = [];
  76. //赢法数组 
  77. var wins = [];
  78. for (var i = 0; i < 15; i++) {
  79.     wins[i] = [];
  80.     for (var j = 0; j < 15; j++) {
  81.         wins[i][j] = [];
  82.     }
  83. }
  84. var count = 0; //赢法总数 
  85. //横线赢法 
  86. for (var i = 0; i < 15; i++) {
  87.     for (var j = 0; j < 11; j++) {
  88.         for (var k = 0; k < 5; k++) {
  89.             wins[i][j + k][count] = true;
  90.         }
  91.         count++;
  92.     }
  93. }
  94. //竖线赢法 
  95. for (var i = 0; i < 15; i++) {
  96.     for (var j = 0; j < 11; j++) {
  97.         for (var k = 0; k < 5; k++) {
  98.             wins[j + k][i][count] = true;
  99.         }
  100.         count++;
  101.     }
  102. }
  103. //正斜线赢法 
  104. for (var i = 0; i < 11; i++) {
  105.     for (var j = 0; j < 11; j++) {
  106.         for (var k = 0; k < 5; k++) {
  107.             wins[i + k][j + k][count] = true;
  108.         }
  109.         count++;
  110.     }
  111. }
  112. //反斜线赢法 
  113. for (var i = 0; i < 11; i++) {
  114.     for (var j = 14; j > 3; j--) {
  115.         for (var k = 0; k < 5; k++) {
  116.             wins[i + k][j - k][count] = true;
  117.         }
  118.         count++;
  119.     }
  120. }
  121. // debugger; 
  122. for (var i = 0; i < count; i++) {
  123.     myWin[i] = 0;
  124.     _myWin[i] = 0;
  125.     computerWin[i] = 0;
  126.     _compWin[i] = 0;
  127. }
  128. var chess = document.getElementById("chess");
  129. var context = chess.getContext('2d');
  130. context.strokeStyle = '#bfbfbf'; //边框颜色 
  131. var backbtn = document.getElementById("goback");
  132. var returnbtn = document.getElementById("return");
  133. window.onload = function() {
  134.     drawChessBoard(); // 画棋盘 
  135. }
  136. document.getElementById("restart").onclick = function() {
  137.     window.location.reload();
  138. }
  139. // 我，下棋 
  140. chess.onclick = function(e) {
  141.     if (over) {
  142.         return;
  143.     }
  144.     if (!me) {
  145.         return;
  146.     }
  147.     // 悔棋功能可用 
  148.     backbtn.className = backbtn.className.replace(new RegExp("(\\s|^)unable(\\s|$)"), " ");
  149.     var x = e.offsetX;
  150.     var y = e.offsetY;
  151.     var i = Math.floor(x / 30);
  152.     var j = Math.floor(y / 30);
  153.     _nowi = i;
  154.     _nowj = j;
  155.     if (chressBord[i][j] == 0) {
  156.         oneStep(i, j, me);
  157.         chressBord[i][j] = 1; //我，已占位置     
  158.  
  159.         for (var k = 0; k < count; k++) { // 将可能赢的情况都加1 
  160.             if (wins[i][j][k]) {
  161.                 // debugger; 
  162.                 myWin[k]++;
  163.                 _compWin[k] = computerWin[k];
  164.                 computerWin[k] = 6; //这个位置对方不可能赢了 
  165.                 if (myWin[k] == 5) {
  166.                     // window.alert('你赢了'); 
  167.                     resultTxt.innerHTML = '恭喜，你赢了！';
  168.                     over = true;
  169.                 }
  170.             }
  171.         }
  172.         if (!over) {
  173.             me = !me;
  174.             computerAI();
  175.         }
  176.     }
  177. }
  178. // 悔棋 
  179. backbtn.onclick = function(e) {
  180.     if (!backAble) {
  181.         return;
  182.     }
  183.     over = false;
  184.     me = true;
  185.     // resultTxt.innerHTML = 'o(?□?)o，悔棋中'; 
  186.     // 撤销悔棋功能可用 
  187.     returnbtn.className = returnbtn.className.replace(new RegExp("(\\s|^)unable(\\s|$)"), " ");
  188.     // 我，悔棋 
  189.     chressBord[_nowi][_nowj] = 0; //我，已占位置 还原 
  190.     minusStep(_nowi, _nowj); //销毁棋子                  
  191.     for (var k = 0; k < count; k++) { // 将可能赢的情况都减1 
  192.         if (wins[_nowi][_nowj][k]) {
  193.             myWin[k]--;
  194.             computerWin[k] = _compWin[k]; //这个位置对方可能赢 
  195.         }
  196.     }
  197.     // 计算机相应的悔棋 
  198.     chressBord[_compi][_compj] = 0; //计算机，已占位置 还原 
  199.     minusStep(_compi, _compj); //销毁棋子                  
  200.     for (var k = 0; k < count; k++) { // 将可能赢的情况都减1 
  201.         if (wins[_compi][_compj][k]) {
  202.             computerWin[k]--;
  203.             myWin[k] = _myWin[i]; //这个位置对方可能赢 
  204.         }
  205.     }
  206.     resultTxt.innerHTML = '--益智五子棋--';
  207.     returnAble = true;
  208.     backAble = false;
  209. }
  210. // 撤销悔棋 
  211. returnbtn.onclick = function(e) {
  212.     if (!returnAble) {
  213.         return;
  214.     }
  215.     // 我，撤销悔棋 
  216.     chressBord[_nowi][_nowj] = 1; //我，已占位置  
  217.     oneStep(_nowi, _nowj, me);
  218.     for (var k = 0; k < count; k++) {
  219.         if (wins[_nowi][_nowj][k]) {
  220.             myWin[k]++;
  221.             _compWin[k] = computerWin[k];
  222.             computerWin[k] = 6; //这个位置对方不可能赢 
  223.         }
  224.         if (myWin[k] == 5) {
  225.             resultTxt.innerHTML = '恭喜，你赢了！';
  226.             over = true;
  227.         }
  228.     }
  229.     // 计算机撤销相应的悔棋 
  230.     chressBord[_compi][_compj] = 2; //计算机，已占位置   
  231.     oneStep(_compi, _compj, false);
  232.     for (var k = 0; k < count; k++) { // 将可能赢的情况都减1 
  233.         if (wins[_compi][_compj][k]) {
  234.             computerWin[k]++;
  235.             _myWin[k] = myWin[k];
  236.             myWin[k] = 6; //这个位置对方不可能赢 
  237.         }
  238.         if (computerWin[k] == 5) {
  239.             resultTxt.innerHTML = 'o(?□?)o，计算机赢了，继续加油哦！';
  240.             over = true;
  241.         }
  242.     }
  243.     returnbtn.className += ' ' + 'unable';
  244.     returnAble = false;
  245.     backAble = true;
  246. }
  247. // 计算机下棋 
  248. var computerAI = function() {
  249.     var myScore = [];
  250.     var computerScore = [];
  251.     var max = 0;
  252.     var u = 0,
  253.         v = 0;
  254.     for (var i = 0; i < 15; i++) {
  255.         myScore[i] = [];
  256.         computerScore[i] = [];
  257.         for (var j = 0; j < 15; j++) {
  258.             myScore[i][j] = 0;
  259.             computerScore[i][j] = 0;
  260.         }
  261.     }
  262.     for (var i = 0; i < 15; i++) {
  263.         for (var j = 0; j < 15; j++) {
  264.             if (chressBord[i][j] == 0) {
  265.                 for (var k = 0; k < count; k++) {
  266.                     if (wins[i][j][k]) {
  267.                         if (myWin[k] == 1) {
  268.                             myScore[i][j] += 200;
  269.                         } else if (myWin[k] == 2) {
  270.                             myScore[i][j] += 400;
  271.                         } else if (myWin[k] == 3) {
  272.                             myScore[i][j] += 2000;
  273.                         } else if (myWin[k] == 4) {
  274.                             myScore[i][j] += 10000;
  275.                         }
  276.  
  277.                         if (computerWin[k] == 1) {
  278.                             computerScore[i][j] += 220;
  279.                         } else if (computerWin[k] == 2) {
  280.                             computerScore[i][j] += 420;
  281.                         } else if (computerWin[k] == 3) {
  282.                             computerScore[i][j] += 2100;
  283.                         } else if (computerWin[k] == 4) {
  284.                             computerScore[i][j] += 20000;
  285.                         }
  286.                     }
  287.                 }
  288.  
  289.                 if (myScore[i][j] > max) {
  290.                     max = myScore[i][j];
  291.                     u = i;
  292.                     v = j;
  293.                 } else if (myScore[i][j] == max) {
  294.                     if (computerScore[i][j] > computerScore[u][v]) {
  295.                         u = i;
  296.                         v = j;
  297.                     }
  298.                 }
  299.  
  300.                 if (computerScore[i][j] > max) {
  301.                     max = computerScore[i][j];
  302.                     u = i;
  303.                     v = j;
  304.                 } else if (computerScore[i][j] == max) {
  305.                     if (myScore[i][j] > myScore[u][v]) {
  306.                         u = i;
  307.                         v = j;
  308.                     }
  309.                 }
  310.  
  311.             }
  312.         }
  313.     }
  314.     _compi = u;
  315.     _compj = v;
  316.     oneStep(u, v, false);
  317.     chressBord[u][v] = 2; //计算机占据位置 
  318.     for (var k = 0; k < count; k++) {
  319.         if (wins[u][v][k]) {
  320.             computerWin[k]++;
  321.             _myWin[k] = myWin[k];
  322.             myWin[k] = 6; //这个位置对方不可能赢了 
  323.             if (computerWin[k] == 5) {
  324.                 resultTxt.innerHTML = 'o(?□?)o，计算机赢了，继续加油哦！';
  325.                 over = true;
  326.             }
  327.         }
  328.     }
  329.     if (!over) {
  330.         me = !me;
  331.     }
  332.     backAble = true;
  333.     returnAble = false;
  334.     var hasClass = new RegExp('unable').test(' ' + returnbtn.className + ' ');
  335.     if (!hasClass) {
  336.         returnbtn.className += ' ' + 'unable';
  337.     }
  338. }
  339. //绘画棋盘 
  340. var drawChessBoard = function() {
  341.     for (var i = 0; i < 15; i++) {
  342.         context.moveTo(15 + i * 30, 15);
  343.         context.lineTo(15 + i * 30, 435);
  344.         context.stroke();
  345.         context.moveTo(15, 15 + i * 30);
  346.         context.lineTo(435, 15 + i * 30);
  347.         context.stroke();
  348.     }
  349. }
  350. //画棋子 
  351. var oneStep = function(i, j, me) {
  352.     context.beginPath();
  353.     context.arc(15 + i * 30, 15 + j * 30, 13, 0, 2 * Math.PI); // 画圆 
  354.     context.closePath();
  355.     //渐变 
  356.     var gradient = context.createRadialGradient(15 + i * 30 + 2, 15 + j * 30 - 2, 13, 15 + i * 30 + 2, 15 + j * 30 - 2, 0);
  357.     if (me) {
  358.         gradient.addColorStop(0, '#0a0a0a');
  359.         gradient.addColorStop(1, '#636766');
  360.     } else {
  361.         gradient.addColorStop(0, '#d1d1d1');
  362.         gradient.addColorStop(1, '#f9f9f9');
  363.     }
  364.     context.fillStyle = gradient;
  365.     context.fill();
  366. }
  367. //销毁棋子 
  368. var minusStep = function(i, j) {
  369.     //擦除该圆 
  370.     context.clearRect((i) * 30, (j) * 30, 30, 30);
  371.     // 重画该圆周围的格子 
  372.     context.beginPath();
  373.     context.moveTo(15 + i * 30, j * 30);
  374.     context.lineTo(15 + i * 30, j * 30 + 30);
  375.     context.moveTo(i * 30, j * 30 + 15);
  376.     context.lineTo((i + 1) * 30, j * 30 + 15);
  377.  
  378.     context.stroke();
  379. }
  380. </script>
  381.  
  382. </body>
  383. </html>

3、五子棋小游戏源代码讲解

五子棋游戏：使用JavaScript和CSS编写五子棋游戏，首先通过HTML构建棋盘界面，每个格子都是可点击的。JavaScript负责处理用户点击事件，记录落子位置，并判断是否有五子连珠的情况。同时，还要实现悔棋、重新开始等功能。CSS则用于美化棋盘和棋子样式。整个源代码逻辑清晰，易于扩展和维护，体现了前端开发的灵活性和实用性。

总结

使用的都是简单的js和css代码，实现了这三款小游戏，复制就能用。一看就能懂。这里分享一下。下次继续。

如果报错，不行也可以下载：2分钟自己写小游戏：使用js和css，快速编写剪刀石布游戏源代码、扫雷源代码、五子棋新手老手毕业论文都能用资源-CSDN文库

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

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

  

闽ICP备14008679号