前言

　　说到贪吃蛇，大家可能小时候都玩过，小菜最近在整理Winfrom的学习系列，那我觉得有兴趣才会有学习，就从这个小游戏讲起吧。

实现

　　其实我刚开始学习编程的时候，感觉写个贪吃蛇的程序会很难，因为涉及到画图什么的，其实现在来看，实现很简单。

　　实现贪吃蛇首先有几个元素：

  • 蛇
  • 食物

　　然后有几个行为：

  • 吃食物和吃不到食物
  • 撞墙和撞自己

　　说到这有点oo的意思啊，这篇就不啰嗦，只是简单实现，下篇会优化下。

　　其实整个贪吃蛇的难点就在于画图，可能用其他语言实现有点复杂，但是强大的.net提供了GDI+绘图机制，实现起来就很方便了，其次就是细节的处理，比如坐标的定位，蛇的行走路线等。

　　我们简单一点来看，食物可以看成一个小方格，蛇是有N个小方格组成，那我们就可以用GDI+这样实现：

  1.          /// <summary>
  2.          /// 画一个小方块
  3.          /// </summary>
  4.          public void DrawShape(int x, int y)
  5.          {
  6.              Graphics g = this.CreateGraphics();
  7.              Pen pen = new Pen(Color.Blue, );
  8.              g.DrawRectangle(pen, x, y, , );
  9.              g.FillRectangle(Brushes.Green, x, y, , );
  10.          }
  11.  
  12.          /// <summary>
  13.          /// 画一个食物
  14.          /// </summary>
  15.          public void DrawFood(int x, int y)
  16.          {
  17.              Graphics g = this.CreateGraphics();
  18.              Pen pen = new Pen(Color.Red, );
  19.              SolidBrush brush = new SolidBrush(Color.Green);
  20.              g.DrawRectangle(pen, x, y, , );
  21.              g.FillRectangle(brush, x, y, , );
  22.          }

　　Graphics这个类我就不多说，大家可以看看MSDN上介绍的用法，上面是画蛇的最小单元-方格，和一个食物方格，蛇的方格大小是15*15，边框颜色是Blue，填充色是Green；食物方格的大小是15*15，边框颜色是Red，填充色是Green。

　　画好了基本元素，那下面就是用基本元素来表现蛇了，可以用Point数组来存储蛇的坐标，也就是每个方格的坐标，我们先看下代码：

  1.          /// <summary>
  2.          /// 设置Point数组坐标
  3.          /// </summary>
  4.          public void Forward(int drt)
  5.          {
  6.              Point temp = snakeArr[];
  7.  
  8.              for (int i = snakeLen-; i > ; i--)
  9.              {
  10.                  snakeArr[i].X = snakeArr[i - ].X;
  11.                  snakeArr[i].Y = snakeArr[i - ].Y;
  12.              }
  13.              switch (drt)
  14.              {
  15.                  case :
  16.                      snakeArr[].X = temp.X;
  17.                      snakeArr[].Y = temp.Y - ;
  18.                      break; //上
  19.                  case :
  20.                      snakeArr[].X = temp.X + ;
  21.                      snakeArr[].Y = temp.Y;
  22.                      break; //右
  23.                  case :
  24.                      snakeArr[].X = temp.X;
  25.                      snakeArr[].Y = temp.Y + ;
  26.                      break; //下
  27.                  case :
  28.                      snakeArr[].X = temp.X - ;
  29.                      snakeArr[].Y = temp.Y;
  30.                      break; //左
  31.              }
  32.          }

　　drt参数是键盘上上下左右键对应的数字，snakeLen是数组的长度也就是方格的个数，上面那个for循环主要的作用是把前一个数组的坐标赋值给下一个，就像是毛毛虫爬行一样，后一节会按照前一节的路线来爬，下面那个switch的作用是，设置蛇头的行进路线。

　　再下面就是判断蛇是否吃到食物、是否撞到墙和撞到自己，因为蛇和食物都是用坐标存储的，所以只要判断蛇头坐标是否等于食物坐标就可以了：

  1.          /// <summary>
  2.          /// 判断是否吃到食物
  3.          /// </summary>
  4.          public bool EatedFoot(Point FoodLct)
  5.          {
  6.              if (snakeArr[].X == FoodLct.X && snakeArr[].Y == FoodLct.Y)
  7.              {
  8.                  if (snakeLen < SnakeMaxLength)
  9.                  {
  10.                      snakeLen++;
  11.                      snakeArr[snakeLen].X = snakeArr[snakeLen - ].X;
  12.                      snakeArr[snakeLen].Y = snakeArr[snakeLen - ].Y;
  13.                  }
  14.                  return true;
  15.              }
  16.              else
  17.                  return false;
  18.          }        
  19.  
  20.          /// <summary>
  21.          /// 判断是否撞到自己
  22.          /// </summary>
  23.          public bool CheckSnakeHeadInSnakeBody()
  24.          {
  25.              return this.CheckInSnakeBody(this.snakeArr[].X, this.snakeArr[].Y, );
  26.          }
  27.          /// <summary>
  28.          /// 检查输入的坐标是否在蛇的身上
  29.          /// </summary>
  30.          public bool CheckInSnakeBody(int x, int y, int snkHead)
  31.          {
  32.              for (int i = snkHead; i < snakeLen; i++)
  33.              {
  34.                  if (x == this.snakeArr[i].X && y == this.snakeArr[i].Y)
  35.                  {
  36.                      return true;
  37.                  }
  38.              }
  39.              return false;
  40.          }
  41.  
  42.          /// <summary>
  43.          /// 判断是否撞墙
  44.          /// </summary>
  45.          /// <returns></returns>
  46.          public bool CheckSnakeBodyInFrm()
  47.          {
  48.              if (this.snakeArr[].X >=  || this.snakeArr[].Y >=  -  || this.snakeArr[].X <  || this.snakeArr[].Y < )
  49.                  return true;
  50.              else
  51.                  return false;
  52.          }

　　实现上面的几个步骤，简单版的贪吃蛇基本上就完成了，再加上一个timer控件，这样蛇就会“动”起来了，就这么简单。

　　完整代码：

  1.  using System;
  2.  using System.Collections.Generic;
  3.  using System.ComponentModel;
  4.  using System.Data;
  5.  using System.Drawing;
  6.  using System.Linq;
  7.  using System.Text;
  8.  using System.Windows.Forms;
  9.  
  10.  namespace 贪吃蛇自练_GDI_
  11.  {
  12.      public partial class Form1 : Form
  13.      {
  14.          public Point FoodLct = new Point();//缓存食物的坐标
  15.          public int snakeLen=;
  16.          public const int SnakeMaxLength = ;
  17.          public Point[] snakeArr = new Point[SnakeMaxLength];
  18.          public int snakeDrt = ;
  19.          public bool panDuan = true;
  20.  
  21.          public Form1()
  22.          {
  23.              InitializeComponent();
  24.  
  25.              int temp = ;
  26.              for (int i = snakeLen - ; i >= ; i--)
  27.              {
  28.                  snakeArr[i].X = temp;
  29.                  snakeArr[i].Y = ;
  30.                  temp += ;
  31.              }
  32.          }
  33.  
  34.          /// <summary>
  35.          /// 画一个小方块
  36.          /// </summary>
  37.          public void DrawShape(int x, int y)
  38.          {
  39.              Graphics g = this.CreateGraphics();
  40.              Pen pen = new Pen(Color.Blue, );
  41.              g.DrawRectangle(pen, x, y, , );
  42.              g.FillRectangle(Brushes.Green, x, y, , );
  43.          }
  44.  
  45.          /// <summary>
  46.          /// 画一个食物
  47.          /// </summary>
  48.          public void DrawFood(int x, int y)
  49.          {
  50.              Graphics g = this.CreateGraphics();
  51.              Pen pen = new Pen(Color.Red, );
  52.              SolidBrush brush = new SolidBrush(Color.Green);
  53.              g.DrawRectangle(pen, x, y, , );
  54.              g.FillRectangle(brush, x, y, , );
  55.          }
  56.  
  57.          /// <summary>
  58.          /// 设置Point数组坐标
  59.          /// </summary>
  60.          public void Forward(int drt)
  61.          {
  62.              Point temp = snakeArr[];
  63.  
  64.              for (int i = snakeLen-; i > ; i--)
  65.              {
  66.                  snakeArr[i].X = snakeArr[i - ].X;
  67.                  snakeArr[i].Y = snakeArr[i - ].Y;
  68.              }
  69.              switch (drt)
  70.              {
  71.                  case :
  72.                      snakeArr[].X = temp.X;
  73.                      snakeArr[].Y = temp.Y - ;
  74.                      break; //上
  75.                  case :
  76.                      snakeArr[].X = temp.X + ;
  77.                      snakeArr[].Y = temp.Y;
  78.                      break; //右
  79.                  case :
  80.                      snakeArr[].X = temp.X;
  81.                      snakeArr[].Y = temp.Y + ;
  82.                      break; //下
  83.                  case :
  84.                      snakeArr[].X = temp.X - ;
  85.                      snakeArr[].Y = temp.Y;
  86.                      break; //左
  87.              }
  88.          }
  89.  
  90.          /// <summary>
  91.          /// 时间事件
  92.          /// </summary>
  93.          private void timer1_Tick(object sender, EventArgs e)
  94.          {
  95.              Graphics g = this.CreateGraphics();
  96.              g.Clear(Color.DarkKhaki);//清除整个画面
  97.  
  98.              Forward(snakeDrt);
  99.              for (int i = ; i < snakeLen; i++)
  100.              {
  101.                  DrawShape(snakeArr[i].X, snakeArr[i].Y);
  102.              }
  103.  
  104.              if (panDuan)
  105.              {
  106.                  ShowFood();
  107.                  //DrawFood(FoodLct.X, FoodLct.Y);
  108.                  panDuan = false;
  109.              }
  110.  
  111.              if (EatedFoot(FoodLct))
  112.              {
  113.                  ShowFood();
  114.                  DrawFood(FoodLct.X, FoodLct.Y);
  115.              }
  116.              else
  117.              {
  118.                  DrawFood(FoodLct.X, FoodLct.Y);
  119.              }
  120.  
  121.              if (CheckSnakeHeadInSnakeBody() || CheckSnakeBodyInFrm())
  122.              {
  123.                  this.timer1.Enabled = false;
  124.                  MessageBox.Show("游戏结束！");
  125.              }
  126.          }
  127.  
  128.          /// <summary>
  129.          /// 按下方向键
  130.          /// </summary>
  131.          private void Form1_KeyDown(object sender, KeyEventArgs e)
  132.          {
  133.              if (e.KeyCode == Keys.Up)
  134.                  snakeDrt = ;
  135.              else if (e.KeyCode == Keys.Down)
  136.                  snakeDrt = ;
  137.              else if (e.KeyCode == Keys.Right)
  138.                  snakeDrt = ;
  139.              else if (e.KeyCode == Keys.Left)
  140.                  snakeDrt = ;
  141.          }
  142.  
  143.          /// <summary>
  144.          /// 判断是否撞到自己
  145.          /// </summary>
  146.          public bool CheckSnakeHeadInSnakeBody()
  147.          {
  148.              return this.CheckInSnakeBody(this.snakeArr[].X, this.snakeArr[].Y, );
  149.          }
  150.          /// <summary>
  151.          /// 检查输入的坐标是否在蛇的身上
  152.          /// </summary>
  153.          public bool CheckInSnakeBody(int x, int y, int snkHead)
  154.          {
  155.              for (int i = snkHead; i < snakeLen; i++)
  156.              {
  157.                  if (x == this.snakeArr[i].X && y == this.snakeArr[i].Y)
  158.                  {
  159.                      return true;
  160.                  }
  161.              }
  162.              return false;
  163.          }
  164.  
  165.          /// <summary>
  166.          /// 判断是否撞墙
  167.          /// </summary>
  168.          /// <returns></returns>
  169.          public bool CheckSnakeBodyInFrm()
  170.          {
  171.              if (this.snakeArr[].X >=  || this.snakeArr[].Y >=  -  || this.snakeArr[].X <  || this.snakeArr[].Y < )
  172.                  return true;
  173.              else
  174.                  return false;
  175.          }
  176.  
  177.          /// <summary>
  178.          /// 随机显示食物
  179.          /// </summary>
  180.          public void ShowFood()
  181.          {
  182.              Random rmd = new Random();
  183.              int x, y;
  184.              x = rmd.Next(, this.Width/)*;
  185.              y = rmd.Next(, this.Height/)*;
  186.              //while (this.CheckInSnakeBody(x, y, 1))
  187.              //{
  188.              //    x = rmd.Next(0, 32) * 15;
  189.              //    y = 32 + rmd.Next(0, 30) * 15;
  190.              //}
  191.              FoodLct.X = x;
  192.              FoodLct.Y = y;
  193.          }
  194.  
  195.          /// <summary>
  196.          /// 判断是否吃到食物
  197.          /// </summary>
  198.          public bool EatedFoot(Point FoodLct)
  199.          {
  200.              if (snakeArr[].X == FoodLct.X && snakeArr[].Y == FoodLct.Y)
  201.              {
  202.                  if (snakeLen < SnakeMaxLength)
  203.                  {
  204.                      snakeLen++;
  205.                      snakeArr[snakeLen].X = snakeArr[snakeLen - ].X;
  206.                      snakeArr[snakeLen].Y = snakeArr[snakeLen - ].Y;
  207.                  }
  208.                  return true;
  209.              }
  210.              else
  211.                  return false;
  212.          }
  213.      }
  214.  }

　　运行截图：

aaarticlea/png;base64,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" alt="" />

　　程序下载：贪吃蛇

　　附录：小菜学习编程-Winform系列（初学者）

后记

　　其实这个简单的小程序需要做的优化有很多，比如上面说的oo，得分模式，蛇行进加速模式等等，希望在下篇来完成。

小菜学习Winform（一）贪吃蛇的更多相关文章

  1. 小菜学习Winform（一）贪吃蛇2

    前言 上一篇<小菜学习Winform(一)贪吃蛇>中实现了简单版的贪吃蛇,在文章末也提到需要优化的地方,比如使用oo.得分模式.速度加快模式和减少界面重绘.因为是优化篇,实现方式上一篇有, ...

  2. 小菜学习Winform（七）系统托盘

    前言 有些程序在关闭或最小化的时候会隐藏在系统托盘中,双击或右击会重新显示,winform实现其功能很简单,这边就简单的介绍下. 实现 在winform实现托盘使用notifyIcon控件,如果加菜单 ...

  3. 小菜学习Winform（六）剪切板和拖放复制

    前言 在做winform项目的时候有时候会用到复制粘贴,在.net中提供了Clipboard类来操作剪切板,我们来看下. clipbrd.exe clipbrd是系统剪切板程序,但是在vista及以上 ...

  4. 小菜学习Winform（五）窗体间传递数据

    前言 做项目的时候,winfrom因为没有B/S的缓存机制,窗体间传递数据没有B/S页面传递数据那么方便,今天我们就说下winfrom中窗体传值的几种方式. 共有字段传递 共有字段传递实现起来很方便, ...

  5. 小菜学习Winform（四）MDI窗体（附示例）

    前言 在做winfrom项目的时候我们可能会用到嵌套窗体,就是说一个容器中有多个窗体,可以分别管理和应用这些窗体,.net中提供了一种机制就是MDI,可能大家都会用,这边就简单的介绍下. 简单应用 w ...

  6. 小菜学习Winform（三）Socket点对点通信

    前言 Socket的英文原义是“孔”或“插座”,其实在网络编程中Socket就是这个意思,就像我们打电话,要首先知道对方的手机号一样,这个手机号就相当于一个Socket号.一个插座,在网络编程中就是i ...

  7. 小菜学习Winform（二）WMPLib实现音乐播放器

    前言 现在网上有很多的音乐播放器,但好像都不是.net平台做的,在.net中实现音乐文件的播放功能很简单,下面就简单实现下. SoundPlayer类 在.net提供了音乐文件的类:SoundPlay ...

  8. 小菜学习编程-Winform系列（初学者）

    前言 记得上次写<小菜的程序员道路(二)>,这篇文章的时候说过,要把工作以来整理的编程知识分享给大家,因为这半年来的工作实在是忙,现在也在忙着公司产品上线,但是答应的一定要实现,大家看我上 ...

  9. 贪吃蛇的java代码分析（一）

    自我审视 最近自己学习java已经有了一个多月的时间,从一开始对变量常量的概念一无所知,到现在能勉强写几个小程序玩玩,已经有了长足的进步.今天没有去学习,学校里要进行毕业答辩和拍毕业照了,于是请了几天 ...

随机推荐

  1. sql 连接数不释放 ，Druid异常：wait millis 40000, active 600, maxActive 600

    Hibernate + Spring + Druid 数据库mysql 由于配置如下 <bean id="dataSource" class="com.alibab ...

  2. webform 光棒效果，删除操作弹出确定取消窗口

    鼠标移入onmouseover和鼠标移出onmouseout,代码里没大写我这也就不大写了.那首先,我们得获取Class为tr_item里的所有东西,也就是项标签里的数据.然后呢,我们定义一个oldC ...

  3. Smart3D系列教程2之 《为什么三维重建效果这么差？——探探那些被忽略的拍照要求和技巧》

    一.照片采集的实用概念 根据照片进行三维重建的过程中,有人没怎么遇到坑,有人被坑的不轻.可能是模型的纹理失真,模型的法线错了,模型会生成我们各种也想不到的结果,那么,是什么导致三维重建效果这么差的?是 ...

  4. MySql怎样去掉某个字段最后的逗号或最后的字

    update 表 set 字段=left(字段,char_length(字段)-1) where right(字段,1)=',';

  5. SQL Server中CROSS APPLY和OUTER APPLY的应用详解

    SQL Server数据库操作中,在2005以上的版本新增加了一个APPLY表运算符的功能.新增的APPLY表运算符把右表表达式应用到左表表达式中的每一行.它不像JOIN那样先计算那个表表达式都可以, ...

  6. C++ 控制台代码输出控制

    在C++控制台应用程序中可以控制控制台输出的字体颜色和 接受任意按键退出 #ifndef CONSOLE_UTILS_H #define CONSOLE_UTILS_H #include <wi ...

  7. iOS开发点滴：iPhone屏幕适配

    最近开始做iOS开发,遇到一些小问题和解决方法,记录下.   今天是iPhone屏幕适配 iPhone5出来之后屏幕就有iPhone就有了2种尺寸:3.5寸和4寸,xcode 5 的IB设计器里面界面 ...

  8. ASP.NET Aries 开源开发框架：开发指南（一）

    前言: 上周开源了Aries开发框架后,好多朋友都Download了源码,在运行过程里,有一些共性的问题会问到. 所以本篇打算写一下简单的开发指南,照顾一下不是太看的懂源码的同学,同时也会讲解一下框架 ...

  9. ReactJs笔记

    中文教程:http://reactjs.cn/ 实例: http://www.ruanyifeng.com/blog/2015/03/react.html

  10. Hadoop学习笔记—4.初识MapReduce

    一.神马是高大上的MapReduce MapReduce是Google的一项重要技术,它首先是一个编程模型,用以进行大数据量的计算.对于大数据量的计算,通常采用的处理手法就是并行计算.但对许多开发者来 ...