暂未完成的扫雷逻辑

最新推荐文章于 2024-01-09 12:17:54 发布
最新推荐文章于 2024-01-09 12:17:54 发布
阅读量610 收藏
点赞数
分类专栏： 2D游戏 文章标签： delete include im struct class null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sryan/article/details/7378344
版权
  
#include <time.h>
#include <stack>
#include <Windows.h>
using namespace std;

// TODO: 在此处引用程序要求的附加头文件
struct MapInfo
{
	bool bMine;
	int nBomboNum;
	bool bShow;
	bool bFind;

	MapInfo()
	{
		bMine=bFind=bShow=false;
		nBomboNum=0;
	}
	void Reset()
	{
		bMine=bFind=bShow=false;
		nBomboNum=0;
	}
};
class MineLogic
{
public:
	MineLogic();
	~MineLogic();
private:
	MapInfo**			m_pMap;
	int					m_nMapWidth;
	int					m_nMapHeight;
	int					m_nLevel;
	int					m_nBomboNum;
	stack<int>			m_stPoint;
public:
	void				InitMap(int nWidth,int nHeight);
	void				DestroyMap();
	void				ResetMap();
	void				RandomMap();
	void				SetLevel(int nLevel);
	void				ShowMap();
	bool				Clicked(int nRow,int nCol);
	void				ShowUserMap();
	void				SetFind(int nRow,int nCol,bool b);
	bool				AllFind();
	bool				GetFind(int nRow,int nCol);
};


 

 

#include "stdafx.h"

// TODO: 在 STDAFX.H 中
//引用任何所需的附加头文件，而不是在此文件中引用

MineLogic::MineLogic()
{
	m_pMap=NULL;
	m_nMapHeight=m_nMapWidth=0;
	m_nLevel=0;//初级 20% 中级40% 高级60%
	m_nBomboNum=0;
}

MineLogic::~MineLogic()
{
	this->DestroyMap();
}

void				MineLogic::InitMap(int nWidth,int nHeight)
{
	this->m_nMapWidth=nWidth;
	this->m_nMapHeight=nHeight;

	if(!m_pMap)
	{
		m_pMap=new MapInfo*[nHeight];

		for(int i=0;i<nHeight;++i)
		{
			*(m_pMap+i)=new MapInfo[nWidth];
		}
	}
}

void				MineLogic::ResetMap()
{
	if(!m_pMap)		return;

	for(int i=0;i<this->m_nMapHeight;++i)
	{
		memset(*(m_pMap+i),0,sizeof(MapInfo));
	}
}

void				MineLogic::SetLevel(int nLevel)
{
	this->m_nLevel=nLevel;
	m_nLevel=(int)m_nMapHeight*m_nMapWidth*nLevel/10;

// 	switch (nLevel)
// 	{
// 	case 0:
// 		{
// 			m_nLevel=(int)m_nMapHeight*m_nMapWidth*0.1f;
// 		}
// 		break;
// 	case 1:
// 		{
// 			m_nLevel=(int)m_nMapHeight*m_nMapWidth*0.3f;
// 		}
// 		break;
// 	case 2:
// 		{
// 			m_nLevel=(int)m_nMapHeight*m_nMapWidth*0.5f;
// 		}
// 		break;
// 	}
}

void				MineLogic::DestroyMap()
{
	for(int i=0;i<this->m_nMapHeight;++i)
	{
		delete[](*(m_pMap+i));
	}
	delete[]m_pMap;
}

void				MineLogic::RandomMap()
{
	if(!m_pMap)
	{
		return;
	}

	this->ResetMap();

	//srand((unsigned int)time(NULL));
	srand(2);
	int n=0;
	int x,y;

	for(int i=0;i<m_nLevel;++i)
	{
		if(!m_pMap[(int)(m_nMapHeight*rand()/(RAND_MAX+1.0))][(int)(m_nMapHeight*rand()/(RAND_MAX+1.0))].bMine)
		{
			m_pMap[(int)(m_nMapHeight*rand()/(RAND_MAX+1.0))][(int)(m_nMapHeight*rand()/(RAND_MAX+1.0))].bMine=true;
		}
		else
		{
			--i;
		}
	}

	for(int i=0;i<m_nMapHeight;++i)
	{
		for(int j=0;j<m_nMapWidth;++j)
		{
			if(m_pMap[i][j].bMine)
			{
				m_pMap[i][j].nBomboNum=n;
				continue;
			}
			else
			{
				x=i-1;y=j-1;
				if(x>=0&&y>=0)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i-1;y=j;
				if(x>=0)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i-1;y=j+1;
				if(x>=0&&y<m_nMapWidth)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i;y=j-1;
				if(y>=0)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i;y=j+1;
				if(y<m_nMapWidth)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i+1;y=j-1;
				if(x<m_nMapHeight&&y>=0)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i+1;y=j;
				if(x<m_nMapHeight)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				x=i+1;y=j+1;
				if(x<m_nMapHeight&&y<m_nMapWidth)
				{
					if(m_pMap[x][y].bMine)
					{
						++n;
					}
				}
				m_pMap[i][j].nBomboNum=n;
			}
			n=0;
		}
	}
}

bool				MineLogic::Clicked(int nRow,int nCol)
{
	m_pMap[nRow][nCol].bShow=true;

	if(m_pMap[nRow][nCol].bMine)
	{
		
		return false;
	}

	if(m_pMap[nRow][nCol].nBomboNum!=0)
	{
		return true;
	}

	int x,y;

	x=nRow-1;y=nCol-1;
	if(x>=0&&y>=0)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow-1;y=nCol;
	if(x>=0)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow-1;y=nCol+1;
	if(x>=0&&y<m_nMapWidth)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow;y=nCol-1;
	if(y>=0)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow;y=nCol+1;
	if(y<m_nMapWidth)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow+1;y=nCol-1;
	if(x<m_nMapHeight&&y>=0)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow+1;y=nCol;
	if(x<m_nMapHeight)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}
	x=nRow+1;y=nCol+1;
	if(x<m_nMapHeight&&y<m_nMapWidth)
	{
		if(!m_pMap[x][y].bShow&&
			m_pMap[x][y].nBomboNum==0&&
			!m_pMap[x][y].bMine)
		{
			m_pMap[x][y].bShow=true;
			m_stPoint.push(x);
			m_stPoint.push(y);
		}
	}

	int preSize=m_stPoint.size();
	while(m_stPoint.size()!=0)
	{
		nCol=m_stPoint.top();
		m_stPoint.pop();
		nRow=m_stPoint.top();
		m_stPoint.pop();

		preSize=m_stPoint.size();
		x=nRow-1;y=nCol-1;
		if(x>=0&&y>=0)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow-1;y=nCol;
		if(x>=0)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow-1;y=nCol+1;
		if(x>=0&&y<m_nMapWidth)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow;y=nCol-1;
		if(y>=0)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow;y=nCol+1;
		if(y<m_nMapWidth)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow+1;y=nCol-1;
		if(x<m_nMapHeight&&y>=0)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow+1;y=nCol;
		if(x<m_nMapHeight)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
		x=nRow+1;y=nCol+1;
		if(x<m_nMapHeight&&y<m_nMapWidth)
		{
			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum==0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
				m_stPoint.push(x);
				m_stPoint.push(y);
			}

			if(!m_pMap[x][y].bShow&&
				m_pMap[x][y].nBomboNum!=0&&
				!m_pMap[x][y].bMine)
			{
				m_pMap[x][y].bShow=true;
			}
		}
	}
	return true;
}

void				MineLogic::ShowMap()
{
	for(int i=0;i<m_nMapWidth;++i)
	{
		for(int j=0;j<m_nMapHeight;++j)
		{
			if(m_pMap[i][j].bMine)
			{
				printf("	B");
			}
			else
			{
				printf("	%d",m_pMap[i][j].nBomboNum);
			}
		}
		printf("\n");
	}
	printf("\n\n");
}

void				MineLogic::ShowUserMap()
{
	for(int i=0;i<m_nMapWidth;++i)
	{
		for(int j=0;j<m_nMapHeight;++j)
		{
			if(m_pMap[i][j].bShow)
			{
				if(m_pMap[i][j].bMine)
				{
					printf("	B");
				}
				else
				{
					printf("	%d",m_pMap[i][j].nBomboNum);
				}
			}
			else
			{
				printf("	X");
			}
			
		}
		printf("\n");
	}
	printf("\n\n");
}

void			MineLogic::SetFind(int nRow,int nCol,bool b)
{
	if(m_pMap[nRow][nCol].bMine)
	{
		m_pMap[nRow][nCol].bFind=b;
	}
}

bool			MineLogic::AllFind()
{
	for(int i=0;i<m_nMapHeight;++i)
	{
		for(int j=0;j<m_nMapWidth;++j)
		{
			if(!m_pMap[i][j].bFind&&
				m_pMap[i][i].bMine)
			{
				return false;
			}
		}
	}
	return true;
}

bool			MineLogic::GetFind(int nRow,int nCol)
{
	return m_pMap[nRow][nCol].bFind;
}


 

碎炎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端技术搭建扫雷小游戏（内含源码）
官方推荐
06-01 3万+
六一儿童节了，为你的小朋友来实现一个扫雷游戏吧！通过扫雷游戏也能让你更进一步的感受前端基础三件套的作用及搭配
Java中扫雷游戏的递归算法_扫雷之递归
weixin_33116629的博客
03-02 1018
前言假前端这货又来了。 上一篇文章，我们已经生成了一张空白的雷区地图，并且将一定数量的地雷随机分布在整个雷区中，最后将环境标识计算出来。生成了一个较完整的雷区地图。 换个样子嗯，地图有点丑，还不直观。 我们利用 vue 的 filters 对地图渲染做一些处理，用 emoji 来展示整张地图。判断逻辑是：格子的数字是 0 ，显示空格子的数字是 9 ，显示炸弹格子是其他数字，仍然显...
C语言-扫雷游戏逻辑实现
最新发布
2301_79642159的博客
01-09 514
统计周围雷数,省事,直接函数返回值,,,这个算法是通过ascll码值来实现的,因为字符012345数字的ascll码值是依次增加,无雷是'0',雷是'1'只要取一个位置周围八个字符的所有ascll的和减去八个'0'的ascll码值就可计算排查位置周围有多少个雷.初始化棋盘和打印棋盘函数,初始化就是用'0'铺满设计棋盘,用'*'铺满展示棋盘,考虑到后续排查雷数要周围数组位置,所以设计时让所需棋盘大一圈,实现计算雷数,打印棋盘就是所需棋盘所以少了一圈,打印时加上横纵轴,便于玩家输入坐标排雷或标记。
C语言扫雷代码 未优化版
shaoxiebug的博客
02-25 44
c语言扫雷未优化版代码
【扫雷】游戏设计——逻辑全分析和代码设计详解
qq_52357718的博客
12-20 1219
自定义函数和扫雷代码的基础实现
贝蒂快扫雷~（C语言）
Bettysweetyaaa的博客
12-20 9844
游戏第二弹：扫雷游戏来喽~
扫雷程序详解
qq_65285898的博客
05-08 1777
一、文件编排 1.需要创建的文件： 一个头文件（game.h）和两个源文件（game.c和function.c） 2.文件的作用： （1）game.h：负责放置函数的声明，头文件引用和标识符常量的定义。 （2）game.c：负责放置主程序的实现，包括进入、退出游戏的程序和游戏的整体实现的函数 （3）function.c：负责放置游戏整体实现函数的内部细节函数 二、实现游戏的进入和退出 1.整体逻辑 （1）首先我们需要打印选择界面，让玩家可以直到如何选择，此时就需要一个menu()函数。
逆向工程第007篇：扫雷辅助的研究——0秒实现一键自动扫雷
Gleam的专栏
05-26 8967
前言 为了给学生讲解游戏辅助的原理，临时起意写了一个扫雷游戏的辅助程序，可真正实现0秒一键自动扫雷等的功能。纵观网上及冀云前辈那本书上的文章，发现已有的资料中存在有这么几个问题：1、无法实现0秒扫雷，都是至少需要1秒才能完成任务；2、雷区究竟是在游戏初始化时就设置好了，还是要等玩家点击了第一处雷区方块才进行设置？3、已有的资料中实现一键扫雷或者地雷自动标记，都是针对于特定的雷区，比如只针对高级模...
扫雷外挂程序开发
zhyh1435589631的专栏
03-13 7492
1. 前言最近突然看到这篇博文： http://blog.csdn.net/zhyh1435589631/article/details/61927733，讲的是制作一个自动扫雷机器人，算法原理也讲清楚了，但是这个是基于windows xp自带的扫雷程序的，由于我们的操作系统是windows 10，已经没有这个默认的扫雷程序了，于是只能从网上直接下载一个下来进行分析，并编写我们自己的扫雷机器人程序。
c代码-未完成扫雷
07-14
【标题】：“C语言实现-未完成扫雷” 在编程领域，扫雷是一款经典的游戏，通常用作教学示例来教授基本的算法和用户界面设计。这个“未完成的扫雷”项目是用C语言编写的，展示了如何利用C语言进行游戏逻辑的构建和...
Win32实现模拟扫雷界面(未实现逻辑功能)
04-29
虽然描述中提到的程序并未实现扫雷的游戏逻辑，但它的核心在于创建一个可视化的用户界面，允许用户与之交互。让我们逐一解析这个过程中的关键知识点。 1. **Win32 API**: Win32 API是Windows操作系统提供的编程接口...
扫雷_扫雷_
10-01
【扫雷游戏简介】 扫雷是一款源于电脑操作系统中的经典单人益智游戏...总的来说，这个C语言实现的扫雷游戏展示了编程逻辑、用户交互和游戏设计的综合应用。通过分析和理解这个游戏，可以加深对C语言及游戏编程的理解。
saolei.rar_扫雷
09-19
【扫雷程序】是一种经典的游戏，它源自于微软Windows操作系统中的内置游戏，旨在锻炼玩家的空间推理和逻辑思维能力。在本项目"saolei.rar_扫雷"中，我们有一个用C++语言编写的扫雷程序。这个程序能够实现扫雷游戏的...
由jQuery制作的扫雷小游戏
06-28
3. **游戏逻辑**：扫雷的规则包括生成随机雷位置、计算相邻雷数、判断游戏胜利或失败等。这部分主要通过JavaScript实现，jQuery则用于与界面交互，比如在计算出相邻雷数后，更新对应方格的显示。 4. **动画效果**：...
HGE学习(1) 粒子系统
sryan的专栏
03-09 1724
为了不重复写代码，自己封装了一下HGE，用着还行。 粒子系统需要指定一个修饰的hgeSprite，及一个例子编辑器做出来的东西，更新了粒子数量后执行Update函数来进行更新，在RenderFunc里画出来。我是用的HGE的例子里面的。 在FrameFunc中更新粒子数量及位置。   #include "SGameBase.h" #include #include #include
通用Astar算法 通用A星算法 通用A*算法
sryan的专栏
12-06 1454
写RPG游戏的时候，解决怪物寻路问题的时候写的，寻路是正确的，效率虽然说不高，但是还是满足了游戏里面的寻路要求。 提供了4个算法，其中2个是用POINT结构体来输入输出的，还有一个是用自定的结构体来输入输出的，同时函数接受一个数据源，只要自己实现那个Adapter的GetData接口就行了，所以无论你的数据是怎么样的，不用改动原先的代码即可寻路。 SEARCH_OFFSET_X和SEARCH_
[D3D] 龙书第三章Cube
sryan的专栏
07-08 1168
#ifndef _D3DC3E1_H_ #define _D3DC3E1_H_ #include "SD3dBase.h" class D3DC3E1:public SD3dBase { public: D3DC3E1(const TCHAR* szTitle):SD3dBase(true,szTitle) { m_pVB = NULL; m_pIB = NULL; } ~D3
HGE学习(2) Target
sryan的专栏
03-09 879
Target我理解为一个场景，在绘制函数中，可以指定为这个场景，即画出来的东西在这个场景的纹理上，然后即可多次在屏幕上画出拥有这个纹理的精灵。       #include "SGameBase.h" #include #include #include #include class MyGame:public SGameBase { public: MyGame(
使用js+html+css完成扫雷
07-20
你可以使用 JavaScript、HTML 和 CSS 来完成一个简单的扫雷游戏。以下是一个基本的实现示例： HTML： ```html <!DOCTYPE html> 扫雷游戏 <div id="board"></div> <script src="script.js"></script> ``...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值