C#带你玩扫雷(附源码)

扫雷游戏,大家都应该玩过吧!其实规则也很简单,可是我们想自己实现一个扫雷,我们应该怎么做呢?

Step1: 知晓游戏原理

扫雷就是要把所有非地雷的格子揭开即胜利;踩到地雷格子就算失败。游戏主区域由很多个方格组成。使用鼠标左键随机点击一个方格,方格即被打开并显示出方格中的数字;方格中数字则表示其周围的8个方格隐藏了几颗雷;如果点开的格子为空白格,即其周围有0颗雷,则其周围格子自动打开;如果其周围还有空白格,则会引发连锁反应;在你认为有雷的格子上,点击右键即可标记雷;如果一个已打开格子周围所有的雷已经正确标出,则可以在此格上同时点击鼠标左右键以打开其周围剩余的无雷格。

1代表1的上下左右及斜角合计有一颗雷,依次轮推,2则有2颗,3则有3颗..

在确实是炸弹的方格上点了旗子,就安全了,不是炸弹的被点了旗子,后面会被炸死的..问号就先不确定这里有没有炸弹,不会存在点错了被炸死的状况..

Step2: 由step1可知,游戏由格子组成,翻译成代码语言就叫做数组,也就是游戏地图就是一个二维数组。格子对象,格子的值即当前雷的数量,那么此时我们暂定雷的数字标识为-1。除此之外,格子对象还有是否被显示,显示当前雷数量等属性,那么我们大概可以定义这样一个类:

 public class CellBlockRole
  {
    /// <summary>
    /// 位于游戏地图中的坐标点X
    /// </summary>
    public int X { get; set; }

    /// <summary>
    /// 位于游戏地图中的坐标点Y
    /// </summary>
    public int Y { get; set; }

    /// <summary>
    /// 是否展示最后格子所代表的结果
    /// </summary>
    public bool IsShowResult { get; set; } = false;

    /// <summary>
    /// 是否计算数字结果
    /// </summary>
    public bool IsComputeResult { get; set; } = false;

    /// <summary>
    /// 是否已经展示过计算结果了
    /// </summary>
    public bool IsHasShowComputed { get; set; } = false;

    /// <summary>
    /// 当前的格子的角色数字, -1:地雷,其他当前雷的数量
    /// </summary>
    public int Number { set; get; } = 0;

    /// <summary>
    /// 是否被Flag标识
    /// </summary>
    public bool IsFlag { get; set; } = false;

    /// <summary>
    /// 是否是雷
    /// </summary>
    public bool IsBoom => Number == -1;

  }

绘制游戏UI画面,见代码:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using SweeperLibrary.Properties;
using Timer = System.Threading.Timer;

namespace SweeperLibrary
{
  public delegate void OnGameOverDelegate();

  public delegate void OnShowANumberDelegate();

  public delegate void OnPublishGameTimeDelegate(string timeDescription);

  public partial class GameView : UserControl
  {

    /// <summary>
    /// 游戏结束事件
    /// </summary>
    public event OnGameOverDelegate OnGameOverEvent;

    /// <summary>
    /// 当一个格子被点击时,显示当前数字的事件
    /// </summary>
    public event OnShowANumberDelegate OnShowANumberEvent;

    /// <summary>
    /// 发布当前游戏的时间
    /// </summary>
    public event OnPublishGameTimeDelegate OnPublishGameTimeEvent;

    /// <summary>
    /// 游戏绘制地图的每个格子的大小
    /// </summary>
    public static readonly int CellSize = 40;

    /// <summary>
    /// 游戏规模N*N
    /// </summary>
    public static readonly int GameCellCount = 10;

    /// <summary>
    /// 移动方向坐标点改变的数组
    /// </summary>
    public static readonly int[][] MoveDirectionPoints = {
      new[]{-1, -1},
      new[] {0, -1},
      new[] {1, -1},
      new[] {1, 0},
      new[] {1, 1},
      new[] {0, 1},
      new[] {-1, 1},
      new[] {-1, 0}
    };

    /// <summary>
    /// 随机数雷生成对象
    /// </summary>
    private static readonly Random random = new Random(Guid.NewGuid().GetHashCode());
    /// <summary>
    /// 游戏地图标识数组
    /// </summary>
    private CellBlockRole[][] gameMap = new CellBlockRole[GameCellCount][];

    /// <summary>
    /// 雷的数量,默认为10
    /// </summary>
    public int BoomCount { get; set; } = 10;

    /// <summary>
    /// 游戏开始时间
    /// </summary>
    private DateTime gameStartTime;

    /// <summary>
    /// 计时定时器
    /// </summary>
    private System.Windows.Forms.Timer gameTimer = new System.Windows.Forms.Timer();

    public GameView()
    {
      InitializeComponent();
      SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
      SetStyle(ControlStyles.AllPaintingInWmPaint, true);
      InitGame(); //默认游戏已经开始
      SetGameTimer(); //设置游戏定时器
    }

    private void GameView_Paint(object sender, PaintEventArgs e)
    {
      Width = GameCellCount + 1 + GameCellCount * CellSize;
      Height = GameCellCount + 1 + GameCellCount * CellSize;
      //绘制游戏界面
      Graphics graphics = e.Graphics;
      graphics.Clear(Color.WhiteSmoke);
      if (gameMap != null && gameMap.Length > 0 && gameMap[0] != null && gameMap[0].Length > 0)
      {
        for (int y = 0; y < GameCellCount; y++)
        {
          for (int x = 0; x < GameCellCount; x++)
          {
            int dx = x + 1 + x * CellSize,
              dy = y + 1 + y * CellSize;
            CellBlockRole cellBlockRole = gameMap[y][x];
            graphics.FillRectangle(new SolidBrush(cellBlockRole.IsShowResult ? Color.LightSlateGray : Color.WhiteSmoke),
              dx, dy, CellSize, CellSize);
            graphics.DrawRectangle(new Pen(Color.LightGray), dx, dy, CellSize, CellSize);
            if (cellBlockRole.IsShowResult && cellBlockRole.Number != 0)
            {
              switch (cellBlockRole.Number)
              {
                case -1: //雷
                  graphics.DrawImage(Image.FromHbitmap(Resources.boom.GetHbitmap()), new RectangleF(dx, dy, CellSize, CellSize));
                  break;
                default: //数字
                  string drawText = cellBlockRole.Number.ToString();
                  Font textFont = new Font(FontFamily.GenericSansSerif, 12, FontStyle.Bold);
                  SizeF textSize = graphics.MeasureString(drawText, textFont);
                  graphics.DrawString(drawText, textFont, new SolidBrush(Color.White),
                    dx + (CellSize - textSize.Width) / 2, dy + (CellSize - textSize.Height) / 2);
                  break;
              }
            }
          }
        }
      }
    }

    private void GameView_MouseDown(object sender, MouseEventArgs e)
    {
      int px = (e.X - 1) / (CellSize + 1),
        py = (e.Y - 1) / (CellSize + 1);
      switch (e.Button)
      {
        case MouseButtons.Left: //鼠标左键
          if (!gameMap[py][px].IsShowResult)
          {
            if (gameMap[py][px].IsBoom)
            {
              new Thread(() =>
              {
                ShowAllCellBlockRoleNumber();
                if (this.InvokeRequired)
                {
                  MethodInvoker del = Invalidate;
                  this.Invoke(del);
                } else
                {
                  Invalidate();
                }
              }).Start();
              gameTimer.Stop();
              OnGameOverEvent?.Invoke();
            } else
            {
              new Thread(() =>
              {
                ShowNeiborhoodCellRolesByPosi(px, py);
                if (this.InvokeRequired)
                {
                  MethodInvoker del = Invalidate;
                  this.Invoke(del);
                } else
                {
                  Invalidate();
                }
              }).Start();
              OnShowANumberEvent?.Invoke();
            }
          }
          break;
        case MouseButtons.Right: //鼠标右键
          break;
      }
    }

    /// <summary>
    /// 初始化游戏
    /// </summary>
    private void InitGame()
    {
      new Thread(() =>
      {
        InitGameMap();
        GenerateBooms();
        if (this.InvokeRequired)
        {
          MethodInvoker del = Invalidate;
          this.Invoke(del);
        } else
        {
          Invalidate();
        }
      }).Start();
    }

    /// <summary>
    /// 设置游戏定时器
    /// </summary>
    private void SetGameTimer()
    {
      gameTimer.Interval = 1000;
      gameTimer.Enabled = true;
      gameTimer.Tick += (sender, args) =>
      {
        long dMillisecond = DateTime.Now.Millisecond - gameStartTime.Millisecond;
        long hour = dMillisecond / 60 / 60 / 1000;
        long minute = (dMillisecond - hour * (60 * 60 * 1000)) / (60 * 1000);
        long second = ((dMillisecond - hour * (60 * 60 * 1000)) % (60 * 1000)) / 1000;
        OnPublishGameTimeEvent?.Invoke((hour > 0 ? (hour > 9 ? hour.ToString() : "0" + hour) + ":" : "")
                        + (minute > 9 ? minute.ToString() : "0" + minute) + ":" + (second > 9 ? second.ToString() : "0" + second));
      };
    }

    /// <summary>
    /// 初始化游戏地图
    /// </summary>
    private void InitGameMap()
    {
      for (int i = 0; i < GameCellCount; i++)
      {
        gameMap[i] = new CellBlockRole[GameCellCount];
        for (int j = 0; j < GameCellCount; j++)
        {
          gameMap[i][j] = new CellBlockRole
          {
            X = j,
            Y = i
          };
        }
      }
      gameStartTime = DateTime.Now;
      gameTimer.Start();
    }

    /// <summary>
    /// 重置游戏地图
    /// </summary>
    public void ResetGameMap()
    {
      new Thread(() =>
      {
        for (int i = 0; i < GameCellCount; i++)
        {
          for (int j = 0; j < GameCellCount; j++)
          {
            gameMap[i][j].X = j;
            gameMap[i][j].Y = i;
            gameMap[i][j].Number = 0;
            gameMap[i][j].IsShowResult = false;
            gameMap[i][j].IsComputeResult = false;
            gameMap[i][j].IsHasShowComputed = false;

          }
        }
        GenerateBooms(); //生成一些雷
        if (this.InvokeRequired)
        {
          MethodInvoker del = Invalidate;
          this.Invoke(del);
        } else
        {
          Invalidate();
        }
      }).Start();
      gameStartTime = DateTime.Now;
      gameTimer.Start();
    }

    /// <summary>
    /// 随机生成一些地雷
    /// </summary>
    public void GenerateBooms()
    {
      for (int i = 0; i < BoomCount; i++)
      {
        int boomNumberIndex = random.Next(0, GameCellCount * GameCellCount - 1); //生成随机数的范围
        int boomX = boomNumberIndex % GameCellCount,
          boomY = boomNumberIndex / GameCellCount;
        if (gameMap[boomY][boomX].Number == 0)
          gameMap[boomY][boomX].Number = -1; //-1表示雷
        else // 已经存在雷了,所以要重新处理
          i--;
      }
      MakeAllNumberComputeInCellRole(0, 0); //默认从坐标(0,0)开始
    }

    /// <summary>
    /// 显示所有的格子的信息
    /// </summary>
    private void ShowAllCellBlockRoleNumber()
    {
      for (int i = 0; i < GameCellCount; i++)
      {
        for (int j = 0; j < GameCellCount; j++)
        {
          gameMap[i][j].IsShowResult = true;
        }
      }
    }

    /// <summary>
    /// 显示某点周边所有格子的数字
    /// </summary>
    /// <param name="posiX">X轴坐标</param>
    /// <param name="posiY">Y轴坐标</param>
    private void ShowNeiborhoodCellRolesByPosi(int posiX, int posiY)
    {
      gameMap[posiY][posiX].IsShowResult = true;
      gameMap[posiY][posiX].IsHasShowComputed = true;
      int boomCount = GetBoomCountInNeiborhood(posiX, posiY);
      if (boomCount == 0) //如果周围没有雷,则翻开所有8个方向的相关数字
      {
        for (int i = 0; i < MoveDirectionPoints.Length; i++)
        {
          int[] itemPosi = MoveDirectionPoints[i];
          int rx = posiX + itemPosi[0],
            ry = posiY + itemPosi[1];
          bool isNotOutIndexRange = rx >= 0 && rx < GameCellCount && ry >= 0 && ry < GameCellCount;
          if (isNotOutIndexRange) //防止坐标溢出
          {
            gameMap[ry][rx].IsShowResult = true;
            if (!gameMap[ry][rx].IsHasShowComputed && gameMap[ry][rx].Number == 0)
              ShowNeiborhoodCellRolesByPosi(rx, ry);
          }
        }
      }
    }

    /// <summary>
    /// 获取某点附近的雷数量
    /// </summary>
    /// <param name="posiX">X轴坐标点</param>
    /// <param name="posiY">Y轴坐标点</param>
    /// <returns></returns>
    private int GetBoomCountInNeiborhood(int posiX, int posiY)
    {
      int boomCount = 0;
      for (int i = 0; i < MoveDirectionPoints.Length; i++)
      {
        int[] itemPosi = MoveDirectionPoints[i];
        int rx = posiX + itemPosi[0],
          ry = posiY + itemPosi[1];
        bool isNotOutIndexRange = rx >= 0 && rx < GameCellCount && ry >= 0 && ry < GameCellCount;
        if (isNotOutIndexRange && gameMap[ry][rx].IsBoom) //防止坐标溢出
        {
          boomCount++;
        }
      }
      return boomCount;
    }

    /// <summary>
    /// 计算每个格子的数字标识
    /// </summary>
    /// <param name="posiX">X轴坐标</param>
    /// <param name="posiY">Y轴坐标</param>
    private void MakeAllNumberComputeInCellRole(int posiX, int posiY)
    {
      int boomCount = GetBoomCountInNeiborhood(posiX, posiY);
      if (boomCount != 0) //如果周围没有雷,则计算周围的8个方向的格子
      {
        gameMap[posiY][posiX].Number = boomCount;
      } else
      {
        if (!gameMap[posiY][posiX].IsBoom)
          gameMap[posiY][posiX].Number = 0;
      }
      gameMap[posiY][posiX].IsComputeResult = true;
      for (int i = 0; i < MoveDirectionPoints.Length; i++)
      {
        int[] itemPosi = MoveDirectionPoints[i];
        int rx = posiX + itemPosi[0],
          ry = posiY + itemPosi[1];
        bool isNotOutIndexRange = rx >= 0 && rx < GameCellCount && ry >= 0 && ry < GameCellCount;
        if (isNotOutIndexRange && !gameMap[ry][rx].IsComputeResult && !gameMap[ry][rx].IsBoom) //防止坐标溢出
        {
          MakeAllNumberComputeInCellRole(rx, ry);
        }
      }
    }

  }

}

主要代码已经实现,现已知现有代码的定时器由问题,暂时不支持Flag(旗子标识)。当然代码中还有其他不足的地方,游戏持续优化中。。。

源代码地址:MineSweeper-CShape_jb51.rar

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

时间: 2017-10-09

详解从零开始---用C#制作扫雷游戏

学C#的原因其实挺简单的,因为一直对游戏挺感兴趣,查了下比较流行的游戏引擎Unity的主要开发语言是C#,所以就决定从C#入手,学学面向对象的编程方法. 以前基本都做的是嵌入式开发,做嵌入式久了,基本上只用C语言,C语言面向过程的特性在嵌入式编程这种资源极度受限的情况确实十分有利,但这种方式在面对大型软件的开发的时候就很难胜任了.编程的模式其实是一种思维习惯,习惯久了以后,想改变确实是一个艰难的过程··· 说起C#,其实在大学的时候学过一个学期,说来惭愧那时候倒也没把它当一门面向对象的语言(其实

详解Android用Shape制作单边框图的两种思路和坑

开发中遇到单/多边框的UI,简单的可以自己写shape图,复杂的一般都让设计配合制作9patch图了. 今天不说需要切图的情况,只聊简单的单/多边框,主要是实现思路. 效果很简单: 就以上图为例介绍,只有上边框,边框红色.宽1dp,其余为白色. 思路一 两层画布叠加:底层红色:上层白色: 上层白色画布下移1dp. 代码实现: <?xml version="1.0" encoding="utf-8"?> <layer-list xmlns:andro

详解在docker中制作自己的JDK+tomcat镜像

也许你和我一样,想要自己亲手制作一个热乎乎的镜像,最好自己指定JDK版本和tomcat版本.当然,这是可以的. 根据我的水平,目前有两种办法可以制作我想要的这个镜像.来,我们先说简单点的. 方式一 首先,准备好想要的jdk和tomcat,另外,我们需要创建一个Dockerfile文件,什么,你说你不知道Dockerfile是什么也不会写Dockerfile文件?哦,那也没关系吧,你Ctrl+C就好了.下面展示一个Dockerfile文件的完整内容: FROM ubuntu:14.10 MAINT

详解使用JS如何制作简单的ASCII图与单极图

ASCII图 在终端执行各种命令的时候经常会看到一些终端里显示出来的"图片",远看仿佛一张图,近看则是一个个的 ASCII码,它们 大致长这样子 而今天我们要做的则是用JS把一张给定的图片转换成这种用ASCII字符组成的"ASCII图" 先看看最终效果,假设我们给定的图片是这样子的, 这是代码处理后的结果,用了 I'mYasic 这8个字符来表示,还是可以分辨出大致的轮廓的. 单级图 而另一种图则是单极图,也就是黑白图片,还是刚刚那张图片,输出如下 基础知识 这两种

详解nodejs模板引擎制作

关于模板,我倒是用过了不少.最开始要数Java的JSP了,然后接触了PHP的smarty,再就是Python的jinja2, Django内置模板,现在刚开始看Nodejs,也发现了不少类似的模板引擎,ejs, jade等等吧. 模板带来的最直接的好处就是加速开发,前后端分离.除此之外,对于字符串的格式化同样是个比较好的应用.习惯了python中 string = "hello {}".format("郭璞") # hello 郭璞 string = "h

C++制作《游戏内存外挂》详解

通过C/C++编程语言编写一个简单的外挂,通过 API 函数修改游戏数据,从而实现作弊功能 对象分析要用的 API 函数简单介绍编写测试效果 一.[对象分析] 本次游戏对象为 Super Mario XP 没有更新所以可用任意版本 试玩发现人物血量最大为 10,心最大为 99,命最大为 99 要用的 API 函数简单介绍 HWND FindWindow(LPCTSTR IpClassName,LPCTSTR IpWindowName); 通过类名或窗口名查找,返回窗口句柄 DWORD GetWi

python制作填词游戏步骤详解

如何用PYTHON制作填词游戏 新建一个PYTHON文档.用JUPYTER NOTEBOOK打开即可. print("Heart is " + color) print(noun + " are red") print("I like " + food) 我们首先确定一下填词的大概方向. color = input("Please enter a color: ") noun = input("Please ente

详解android studio游戏摇杆开发教程,仿王者荣耀摇杆

最近在做一个山寨版的王者荣耀,刚开始做的时候毫无头绪 摇杆的多点触控做的特别烂 经过几天的思考已完美解决所有问题,下面就和大家分享下这个摇杆的开发思路 若有不正之处,请多多谅解并欢迎指正. 首先这个摇杆要用到较多的数学知识,小编的数学特别烂也就高中水平吧 我们这个摇杆一共就五个按钮,一个移动摇杆.三个技能摇杆和一个普通攻击按钮 最终效果 好了废话少说让我们开始吧 新建一个项目 建好项目之后,我们先新建一个类叫做"画".也是我们的主View 修改Hua.java的代码 public cl

Java太阳系小游戏分析和源码详解

最近看了面向对象的一些知识,然后跟着老师的讲解做了一个太阳系各行星绕太阳转的小游戏,来练习巩固一下最近学的知识: 用到知识点:类的继承.方法的重载与重写.多态.封装等 分析: 1.需要加载图片.画图 2.建一个面板,主页面 3.行星类 效果图: 先看一下源码结构图: 现在逐步分析各个类的功能: 1)工具类-----util包中 --Constant类   封装了游戏中用到的常量 --GameUtil类  封装了游戏的图片加载功能 --MyFrame类  封装了游戏面板的构造,用于各面板的父类 -

JSP 制作验证码的实例详解

JSP 制作验证码的实例详解 验证码 验证码(CAPTCHA)是"Completely Automated Public Turing test to tell Computers and Humans Apart"(全自动区分计算机和人类的图灵测试)的缩写,是一种区分用户是计算机还是人的公共全自动程序.可以防止:恶意破解密码.刷票.论坛灌水,有效防止某个黑客对某一个特定注册用户用特定程序暴力破解方式进行不断的登陆尝试,实际上用验证码是现在很多网站通行的方式,我们利用比较简易的方式实现