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

前端实战小案例--canvas实战之FlappyBird小游戏_flappy bird 前端

作者：我家自动化 | 2024-03-27 10:18:04

赞

踩

flappy bird 前端

前端实战小案例--canvas实战之FlappyBird小游戏

想练习更多前端案例，请进个人主页，点击前端实战案例->传送门

觉得不错的记得点个赞?支持一下我0.0！谢谢了！

不积跬步无以至千里，不积小流无以成江海。

效果图如下：(由于图片有大小限制，所以录制的是10帧，有点卡顿的感觉，实际是很流畅的)

素材如下：

 

文件结构目录如下：

代码如下：

index.html

  1. <!DOCTYPE html>
  2. <html>
  3. 	<head>
  4. 		<meta charset="utf-8">
  5. 		<meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no">
  6. 		<title>FlappyBird</title>
  7. 		<link rel="stylesheet" href="./css/index.css" />
  8. 	</head>
  9. 	<body>
  10. 		<canvas>
  11. 			<span>您的浏览器不支持画布元素，请使用谷歌浏览器</span>
  12. 		</canvas>
  13. 	</body>
  14. 	<script src="./js/Game.js"></script>
  15. 	<script src="./js/Background.js"></script>
  16. 	<script src="./js/Land.js"></script>
  17.     <script src="./js/Pipe.js"></script>
  18.     <script src="./js/Bird.js"></script>
  19. 	<script src="./js/SceneManager.js"></script>
  20. 	<script>
  21. 		var game = new Game();
  22. 	</script>
  23. </html>

index.css

  1. *{
  2. 	margin: 0;
  3. 	padding: 0;
  4. }
  5.  
  6. canvas{
  7. 	display: block;
  8. 	margin: 0 auto;
  9. }

resource.json

  1. [
  2. 	{
  3. 		"imgs":[
  4. 			{"name":"Back1", "url":"./resource/images/Back1.png"},
  5. 			{"name":"Bird", "url":"./resource/images/Bird.png"},
  6. 			{"name":"Flash", "url":"./resource/images/Flash.png"},
  7. 			{"name":"Logo", "url":"./resource/images/Logo.png"},
  8. 			{"name":"Number", "url":"./resource/images/Number.png"},
  9. 			{"name":"Land2", "url":"./resource/images/Road2.png"},
  10.             {"name":"Pipe1", "url":"./resource/images/Pipe1.png"},
  11.             {"name":"Pipe2", "url":"./resource/images/Pipe2.png"},
  12. 			{"name":"Bomb", "url":"./resource/images/Bomb.png"}
  13. 		]
  14. 	}
  15. ]

Background.js

  1. //背景类
  2. (function () {
  3.     var Background = window.Background = function () {
  4.         this.image = game.imgArr["Back1"];
  5.         this.speed = 0;
  6.     };
  7.     Background.prototype.render = function () {
  8.         game.ctx.clearRect(0,0,game.canvas.width,game.canvas.height);
  9.         game.ctx.drawImage(this.image,this.speed,game.canvas.height*0.618-this.image.height*0.618);
  10.         game.ctx.drawImage(this.image,this.image.width+this.speed,game.canvas.height*0.618-this.image.height*0.618);
  11.         game.ctx.drawImage(this.image,this.image.width*2+this.speed,game.canvas.height*0.618-this.image.height*0.618);
  12.         game.ctx.save();
  13.         game.ctx.fillStyle = "#4EC0CA";
  14.         game.ctx.beginPath();
  15.         game.ctx.fillRect(0,0,game.canvas.width,game.canvas.height*0.618-this.image.height*0.618+10);
  16.         game.ctx.restore();
  17.         game.ctx.save();
  18.         game.ctx.fillStyle = "#DED895";
  19.         game.ctx.beginPath();
  20.         game.ctx.fillRect(0,game.canvas.height*0.618+this.image.height*(1-0.618)-10,game.canvas.width,game.canvas.height*(1-0.618)-this.image.height*(1-0.618)+10);
  21.         game.ctx.restore();
  22.     };
  23.     Background.prototype.update = function () {
  24.         this.speed--;
  25.         if(-this.speed === this.image.width){
  26.             this.speed = 0;
  27.         }
  28.     }
  29. })();

Bird.js

  1. (function () {
  2.     var Bird = window.Bird = function () {
  3.         this.image = game.imgArr["Bird"];
  4.         this.x = game.canvas.width*(1-0.618);
  5.         this.y = game.canvas.height*0.618*(1-0.618);
  6.         //小鸟旋转的角度
  7.         this.deg = 0;
  8.         //小鸟是否在飞
  9.         this.isFly = false;
  10.         //帧数
  11.         this.fno = 0;
  12.         //鸟的颜色
  13.         this.birdColor = 24*parseInt(Math.random()*3);
  14.         //鸟扇动翅膀的图片的编号
  15.         this.wingNo = 0;
  16.         //下面的四个变量用于碰撞检测,代表鸟的上下左右的最小矩形框
  17.         this.L = this.R = this.T = this.B = 0;
  18.         //该变量用于保存鸟是否为死亡状态
  19.         this.isDie = false;
  20.     };
  21.     Bird.prototype.render = function () {
  22.         game.ctx.save();
  23.         game.ctx.translate(this.x,this.y);
  24.         game.ctx.rotate(this.deg);
  25.         game.ctx.beginPath();
  26.         game.ctx.drawImage(this.image,34*this.wingNo,this.birdColor,34,24,-17,-12,34,24);
  27.         game.ctx.restore();
  28.         // game.ctx.fillRect(this.L,this.T,34,24);
  29.  
  30.     };
  31.     Bird.prototype.update = function () {
  32.         this.L = this.x-17;
  33.         this.R = this.x + 17;
  34.         this.T = this.y-12;
  35.         this.B = this.y + 12;
  36.  
  37.         //判断鸟是否飞出天空，真则不让飞出,
  38.         if(this.T < 0){
  39.             //这里不能使用this.T = 0;因为
  40.             //game.ctx.drawImage(this.image,34*this.wingNo,this.birdColor,34,24,-17,-12,34,24);
  41.             //game.ctx.translate(this.x,this.y);这里是根据x,y来绘制鸟的，固定T鸟还是飞出屏幕
  42.             this.y = 12;
  43.         }
  44.         if(this.isFly){
  45.             //这里为扇动翅膀动画
  46.             if(this.fno%2 === 0){
  47.                 this.wingNo++;
  48.             }
  49.             if(this.wingNo > 2){
  50.                 this.wingNo = 0;
  51.             }
  52.             //当有点击事件时，鸟儿向上飞一段距离
  53.             this.y -= 0.4 * (20-this.fno);
  54.             if(this.fno === 20){
  55.                 this.fno = 0;
  56.                 this.isFly = false;
  57.             }
  58.             this.deg -= (Math.PI/180)*6;
  59.             if(this.deg < -(Math.PI/180)*45){
  60.                 this.deg = -(Math.PI/180)*45;
  61.             }
  62.         }else{
  63.             this.y += 0.4 * this.fno;
  64.             this.deg += (Math.PI/180)*3;
  65.             if(this.deg > (Math.PI/180)*90){
  66.                 this.deg = (Math.PI/180)*90;
  67.             }
  68.         }
  69.         this.fno++;
  70.     };
  71.     Bird.prototype.fly = function () {
  72.         this.fno = 0;
  73.         this.isFly = true;
  74.     }
  75. })();

Game.js

  1. (function(){
  2. 	var Game = window.Game = function(){
  3. 		this.canvas = document.querySelector("canvas");
  4. 		this.canvas.width = document.documentElement.clientWidth;
  5. 		this.canvas.height = document.documentElement.clientHeight;
  6.         this.init();
  7.         this.ctx = this.canvas.getContext('2d');
  8.         //这是图片字典
  9. 		this.imgArr = {};
  10. 		//这是管子数组
  11.         this.pipeArr = [];
  12.         //游戏分数：即通过的管子数
  13.         this.score = 0;
  14.  
  15.         //记录过多少时间new一个管子
  16.         this.time_count = 0;
  17.  
  18.         //这里也需要使用箭头函数，否则this指向window而不是window.Game
  19. 		this.loadResource(()=>{
  20. 		    this.startGame();
  21.         });
  22. 	};
  23.  
  24. 	//初始化画布宽高，适配移动端不同机型
  25. 	Game.prototype.init =  function(){
  26. 		if(this.canvas.width < 320){
  27. 			this.canvas.width = 320;
  28. 		}else if(this.canvas.width > 414){
  29. 			this.canvas.width = 414;
  30. 		}
  31. 		if(this.canvas.height < 568){
  32. 			this.canvas.height = 568;
  33. 		}else if(this.canvas.height > 823){
  34. 			this.canvas.height = 823;
  35. 		}
  36. 	};
  37.  
  38. 	//加载资源
  39. 	Game.prototype.loadResource = function(callback){
  40. 		//定义已加载的资源数
  41. 		var resource_count = 0;
  42. 		var xhr = new XMLHttpRequest();
  43. 		//这里需使用箭头函数，否则将出现this指向错误，
  44. 		xhr.onreadystatechange = ()=>{
  45. 		    //此时的this指向window.Game
  46. 			if(xhr.readyState === 4 && xhr.status === 200){
  47. 				var obj = JSON.parse(xhr.responseText);
  48. 				for(let i=0;i<obj[0]["imgs"].length;i++){
  49.                     this.imgArr[obj[0]["imgs"][i].name] = new Image();
  50.                     this.imgArr[obj[0]["imgs"][i].name].src = obj[0]["imgs"][i].url;
  51.                     this.imgArr[obj[0]["imgs"][i].name].onload = ()=> {
  52.                         resource_count++;
  53.                         this.ctx.clearRect(0,0,this.canvas.width,this.canvas.height);
  54.                         this.ctx.save();
  55.                         let text = "正在加载资源"+ resource_count +"/"+obj[0]["imgs"].length;
  56.                         this.ctx.textAlign = "center";
  57.                         this.ctx.font = "20px 微软雅黑";
  58.                         this.ctx.beginPath();
  59.                         this.ctx.fillText(text,this.canvas.width/2,this.canvas.height*(1-0.618));
  60.                         this.ctx.restore();
  61.                         //当加载图片的数量等于图片资源的数量时，说明图片资源加载完毕，执行回调函数
  62.                         if(resource_count === obj[0]["imgs"].length){
  63.                             callback();
  64.                         }
  65.                     }
  66. 				}
  67. 			}
  68. 		};
  69. 		xhr.open('GET',"./resource.json");
  70. 		xhr.send();
  71. 	};
  72.  
  73.     //主线程：游戏开始
  74.     Game.prototype.startGame = function () {
  75.         //实例化场景管理器
  76.         this.sm = new SceneManager();
  77.  
  78.         this.timer = setInterval(()=>{
  79.             this.time_count += 20;
  80.  
  81.             this.sm.render();
  82.             this.sm.update();
  83.         },20)
  84.     };
  85. })();

Land.js

  1. //大地类
  2. (function () {
  3.     var Land = window.Land = function () {
  4.         this.image = game.imgArr["Land2"];
  5.         this.speed = 0;
  6.     };
  7.  
  8.     Land.prototype.render =  function () {
  9.         game.ctx.drawImage(this.image,this.speed,game.canvas.height*0.618+99);
  10.         game.ctx.drawImage(this.image,this.image.width+this.speed,game.canvas.height*0.618+99);
  11.     };
  12.  
  13.     Land.prototype.update =  function () {
  14.         //每次更新判断鸟是否着地，着地则结束游戏
  15.         if(game.bird.B > game.canvas.height*0.618+80){
  16.             game.bird.isDie = true;
  17.         }
  18.         //近处的物体速度快，故大地的速度比远处的树林和白云快
  19.         this.speed-=2;
  20.  
  21.         if(-this.speed > 640){
  22.             this.speed = 0;
  23.         }
  24.     }
  25. })();

Pipe.js

  1. (function () {
  2.     var Pipe = window.Pipe = function () {
  3.         this.Pipe1 = game.imgArr["Pipe1"];
  4.         this.Pipe2 = game.imgArr["Pipe2"];
  5.         this.height = game.canvas.height*0.618+99;
  6.         //两个管子之间的空隙高度
  7.         this.interspace = 150;
  8.         //上面的管子随机高度
  9.         this.randomHeight = 140 + parseInt(Math.random()*180);
  10.         //下面的管子的高度等于this.height-this.randomHeight-this.interspace
  11.         this.Pipe2_height = this.height-this.randomHeight-this.interspace;
  12.         this.speed = 0;
  13.         //该变量用于碰撞检测
  14.         this.L = 0;
  15.         //该变量用于判断鸟是否已经通过管子，防止重复加分
  16.         this.alreadyPass = false;
  17.         //将自己推入数组
  18.         game.pipeArr.push(this);
  19.     };
  20.  
  21.     Pipe.prototype.render = function () {
  22.         this.L = game.canvas.width+10+this.speed;
  23.         //当下面的管子高度小于40时，重新取值
  24.         while (this.Pipe2_height < 40){
  25.             this.randomHeight = 140 + parseInt(Math.random()*180);
  26.             this.Pipe2_height = this.height-this.randomHeight-this.interspace;
  27.         }
  28.         game.ctx.drawImage(this.Pipe1, 0, this.Pipe1.height-this.randomHeight, 52, this.randomHeight, this.L, 0, 52, this.randomHeight);
  29.         game.ctx.drawImage(this.Pipe2, 0, 0, 52, this.Pipe2_height, this.L,  this.randomHeight+this.interspace, 52, this.Pipe2_height);
  30.     };
  31.  
  32.     Pipe.prototype.update = function () {
  33.  
  34.         //每次更新判断管子是否碰到鸟clearInterval(game.timer)
  35.         if(this.L < game.bird.R && this.L+52 > game.bird.L){
  36.             if(this.randomHeight > game.bird.T || this.randomHeight + this.interspace < game.bird.B){
  37.                 game.bird.isDie = true;
  38.             }
  39.         }
  40.         this.speed -= 2;
  41.         //判断鸟是否通过管子，真则加分
  42.         if(game.bird.L > game.canvas.width+this.speed+52 && !this.alreadyPass){
  43.             game.score++;
  44.             this.alreadyPass = true;
  45.         }
  46.  
  47.         //当管子移出画布时，将其从数组中移除
  48.         if(-this.speed > game.canvas.width + 60){
  49.             game.pipeArr.shift();
  50.             this.speed = 0;
  51.         }
  52.     }
  53. })();

SceneManager.js

  1. (function () {
  2.     var sm = window.SceneManager = function () {
  3.         //sm的场景编号
  4.         this.sceneNo = 1;
  5.         //实例化背景
  6.         game.bg = new Background();
  7.         //实例化大地
  8.         game.land = new Land();
  9.         //实例化鸟
  10.         game.bird = new Bird();
  11.         //Flash和Logo图片的Y值
  12.         this.FlashY = 0;
  13.         this.LogoY = game.canvas.height;
  14.         this.bindEvent();
  15.         //这两个参数用于控制爆炸效果
  16.         this.i = 0;
  17.         this.j = 0;
  18.         //这个参数用于控制鸟死亡下落的重力
  19.         this.g = 1;
  20.     };
  21.     sm.prototype.update = function () {
  22.         switch (this.sceneNo) {
  23.             case 1:
  24.                 this.FlashY += 4;
  25.                 this.LogoY -= 4;
  26.                 if(this.FlashY > game.canvas.height * (1-0.618)){
  27.                     this.FlashY = game.canvas.height * (1-0.618);
  28.                 }
  29.                 if(this.LogoY < game.canvas.height * (1-0.618)+100){
  30.                     this.LogoY = game.canvas.height * (1-0.618)+100
  31.                 }
  32.                 break;
  33.             case 2:
  34.                 //判断鸟是否死亡，真则切换到场景3
  35.                 if(game.bird.isDie){
  36.                     this.enter(3)
  37.                 }
  38.                 break;
  39.             case 3:
  40.                 this.g ++;
  41.                 if(game.bird.y < game.canvas.height*0.618+99){
  42.                     game.bird.y += 0.4 * this.g;
  43.                 }else{
  44.                     this.enter(4);
  45.                 }
  46.                 break;
  47.             case 4:
  48.                 if(game.time_count%100 === 0){
  49.                     this.i++;
  50.                     if(this.i > 3 && this.j === 0){
  51.                         this.i = 0;
  52.                         this.j = 1;
  53.                     }else if(this.i > 3 && this.j === 1){
  54.                         this.i = 3;
  55.                         this.j = 1;
  56.                         this.enter(5);
  57.                     }
  58.                 }
  59.                 break;
  60.             case 5:
  61.                 this.FlashY += 4;
  62.                 if(this.FlashY > game.canvas.height * (1-0.618)){
  63.                     this.FlashY = game.canvas.height * (1-0.618);
  64.                 }
  65.                 break;
  66.         }
  67.     };
  68.     sm.prototype.render = function () {
  69.         //清屏
  70.         game.ctx.clearRect(0,0,game.canvas.width,game.canvas.height);
  71.         switch (this.sceneNo) {
  72.             case 1:
  73.                 //场景1：游戏开始界面
  74.                 game.bg.render();
  75.                 game.land.render();
  76.                 game.bg.update();
  77.                 game.land.update();
  78.                 game.ctx.drawImage(game.imgArr["Flash"],0,0,204,69,game.canvas.width / 2 - 102,this.FlashY,204,69);
  79.                 game.ctx.drawImage(game.imgArr["Logo"],game.canvas.width / 2 - 160,this.LogoY);
  80.                 break;
  81.             case 2:
  82.                 //场景2：游戏开始
  83.                 //每隔两秒new一个管子
  84.                 if(game.time_count > 2000){
  85.                     game.time_count = 0;
  86.                     new Pipe();
  87.                 }
  88.  
  89.                 game.bg.render();
  90.                 game.land.render();
  91.                 game.bg.update();
  92.                 game.land.update();
  93.  
  94.                 //遍历管子数组，更新并渲染
  95.                 for (let i=0;i<game.pipeArr.length;i++){
  96.                     game.pipeArr[i].update();
  97.                     game.pipeArr[i].render();
  98.                 }
  99.                 game.bird.update();
  100.                 game.bird.render();
  101.  
  102.                 //绘制游戏分数
  103.                 game.ctx.save();
  104.                 game.ctx.font = "26px 微软雅黑";
  105.                 game.ctx.textBaseline = "top";
  106.                 game.ctx.beginPath();
  107.                 game.ctx.fillText("分数：",0,15);
  108.                 game.ctx.restore();
  109.                 var number = game.score.toString();
  110.                 for(let i=0; i<number.length; i++){
  111.                     game.ctx.drawImage(game.imgArr["Number"],28*parseInt(number[i]),0,28,36,28*i+75,10,28,36);
  112.                 }
  113.                 break;
  114.             case 3:
  115.                 //场景3：小鸟撞地死亡
  116.                 //每隔两秒new一个管子
  117.                 if(game.time_count === 2000){
  118.                     game.time_count = 0;
  119.                     new Pipe();
  120.                 }
  121.  
  122.                 game.bg.render();
  123.                 game.land.render();
  124.  
  125.                 //遍历管子数组，更新并渲染
  126.                 for (let i=0;i<game.pipeArr.length;i++){
  127.                     game.pipeArr[i].render();
  128.                 }
  129.                 game.bird.render();
  130.  
  131.                 //绘制游戏分数
  132.                 game.ctx.save();
  133.                 game.ctx.font = "26px 微软雅黑";
  134.                 game.ctx.textBaseline = "top";
  135.                 game.ctx.beginPath();
  136.                 game.ctx.fillText("分数：",0,15);
  137.                 game.ctx.restore();
  138.                 var number = game.score.toString();
  139.                 for(let i=0; i<number.length; i++){
  140.                     game.ctx.drawImage(game.imgArr["Number"],28*parseInt(number[i]),0,28,36,28*i+75,10,28,36);
  141.                 }
  142.                 break;
  143.             case 4:
  144.                 //游戏结束：鸟撞管子死亡动画
  145.                 //每隔两秒new一个管子
  146.                 if(game.time_count === 2000){
  147.                     game.time_count = 0;
  148.                     new Pipe();
  149.                 }
  150.  
  151.                 game.bg.render();
  152.                 game.land.render();
  153.  
  154.                 //遍历管子数组，更新并渲染
  155.                 for (let i=0;i<game.pipeArr.length;i++){
  156.                     game.pipeArr[i].render();
  157.                 }
  158.  
  159.                 //绘制游戏分数
  160.                 game.ctx.save();
  161.                 game.ctx.font = "26px 微软雅黑";
  162.                 game.ctx.textBaseline = "top";
  163.                 game.ctx.beginPath();
  164.                 game.ctx.fillText("分数：",0,15);
  165.                 game.ctx.restore();
  166.                 var number = game.score.toString();
  167.                 for(let i=0; i<number.length; i++){
  168.                     game.ctx.drawImage(game.imgArr["Number"],28*parseInt(number[i]),0,28,36,28*i+75,10,28,36);
  169.                 }
  170.                 //当鸟的y值大于地面的高度，则产生爆炸效果
  171.                 if(game.bird.y > game.canvas.height*0.618+99){
  172.                     game.ctx.drawImage(game.imgArr["Bomb"],128*this.i,128*this.j,128,128,game.bird.x-34,game.bird.y-34,34*2,34*2);
  173.                 }
  174.                 break;
  175.             case 5:
  176.                 //游戏结束：GameOver
  177.                 if(game.time_count === 2000){
  178.                     game.time_count = 0;
  179.                     new Pipe();
  180.                 }
  181.  
  182.                 game.bg.render();
  183.                 game.land.render();
  184.  
  185.                 //遍历管子数组，更新并渲染
  186.                 for (let i=0;i<game.pipeArr.length;i++){
  187.                     game.pipeArr[i].render();
  188.                 }
  189.  
  190.                 //绘制游戏分数
  191.                 game.ctx.save();
  192.                 game.ctx.font = "26px 微软雅黑";
  193.                 game.ctx.textBaseline = "top";
  194.                 game.ctx.beginPath();
  195.                 game.ctx.fillText("分数：",0,15);
  196.                 game.ctx.restore();
  197.                 var number = game.score.toString();
  198.                 for(let i=0; i<number.length; i++){
  199.                     game.ctx.drawImage(game.imgArr["Number"],28*parseInt(number[i]),0,28,36,28*i+75,10,28,36);
  200.                 }
  201.                 //GameOver图标往下移动到屏幕中间
  202.                 game.ctx.drawImage(game.imgArr["Flash"],204,0,204,69,game.canvas.width / 2 - 102,this.FlashY,204,69);
  203.  
  204.         }
  205.     };
  206.     //进入某个场景时需要做的操作
  207.     sm.prototype.enter = function (sceneNo) {
  208.         switch (sceneNo) {
  209.             case 1:
  210.                 this.sceneNo = 1;
  211.                 this.FlashY = 0;
  212.                 this.LogoY = game.canvas.height;
  213.                 game.bird = new Bird();
  214.                 //实例化背景
  215.                 game.bg = new Background();
  216.                 //实例化大地
  217.                 game.land = new Land();
  218.                 game.pipeArr = [];
  219.                 game.time_count = 0;
  220.                 game.score = 0;
  221.                 //这两个参数用于控制爆炸效果
  222.                 this.i = 0;
  223.                 this.j = 0;
  224.                 //这个参数用于控制鸟死亡下落的重力
  225.                 this.g = 1;
  226.                 break;
  227.             case 2:
  228.                 this.sceneNo = 2;
  229.                 //sm的场景编号
  230.                 break;
  231.             case 3:
  232.                 this.sceneNo = 3;
  233.                 break;
  234.             case 4:
  235.                 this.sceneNo = 4;
  236.                 break;
  237.             case 5:
  238.                 this.sceneNo = 5;
  239.                 this.FlashY = 0;
  240.                 break;
  241.         }
  242.     };
  243.     //
  244.     sm.prototype.bindEvent = function () {
  245.         //当点击canvas时，通过判断在哪个场景的哪个位置来做出相应的事件
  246.         game.canvas.onclick =  () => {
  247.             switch (this.sceneNo) {
  248.                 case 1:
  249.                     game.bird.isDie = false;
  250.                     game.bird.x = game.canvas.width*(1-0.618);
  251.                     game.bird.y = game.canvas.height*0.618*(1-0.618);
  252.                     this.enter(2);
  253.                     break;
  254.                 case 2:
  255.                     game.bird.fly();
  256.                     break;
  257.                 case 3:
  258.                     break;
  259.                 case 4:
  260.                     break;
  261.                 case 5:
  262.                     this.enter(1);
  263.                     break;
  264.             }
  265.         }
  266.     }
  267. })();

 

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

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

  

闽ICP备14008679号