C语言实现可视化，运用EasyX实现拼图+文字解谜+迷宫+猜数游戏_c语言 可视化

文字解谜游戏：梦境寻踪

开发语言：C语言
开发工具：vs2019+EasyX
开发人员：杨富超，王昊，孟桐冰，郭宇
故事部分：孟桐冰，郭宇
代码部分：杨富超，王昊
CSDN源码下载：梦境寻踪源码
如有疑问，欢迎留言
给初学者：关于VS2019怎么安装EasyX
EasyX文档：EasyX函数文档

前言

这个是用了1周左右的休闲时间，来和四个同学完成的，感觉EasyX确实适合C语言初学者学习，做做小游戏，芜湖，终于结尾了，第一个小游戏，nice
大学以后可以记忆挺深的一个事了。

一，游戏展示

头文件

#include<graphics.h>      // 引用图形库头文件
#include<stdio.h>       
#include<stdlib.h>
#include<conio.h>         //InputBox,MessageBox
#include<time.h>         //随机种子   
#include<mmsystem.h>    //bgm
#include<windows.h>     //bgm
#include "maze.h"       //迷宫
#pragma comment(lib,"winmm.lib")   //bgm
1
2
3
4
5
6
7
8
9

二，关于EasyX如何实现展示图片与鼠标操作

展示图片原理分享：展示图片EasyX做的很简单，首先，先用 IMAGE 定义一个图片的变量，然后给变量赋值。

运用函数：IMAGE，initgraph，loadimage，putimage
U1S1这几个函数开始后陌生，后面用着就熟悉了

代码：

#include <graphics.h>
#include <conio.h>//头文件
IMAGE start//定义变量
int main()
{
  initgraph(1366, 700);//定义窗口大小长，宽
  loadimage(&start, L"picture\\start.jpg");//赋值操作，把路径的图片赋值给start（之前定义的变量）
  putimage(0, 0, &start);//从x=0，y=0，开始展示start赋值的图片，即picture\\start.jpg
}
1
2
3
4
5
6
7
8
9

鼠标操作原理：先定义1块长宽确定的窗口，再通过x,y坐标确定鼠标位置。

运用函数：MOUSEMSG，FlushMouseMsgBuffer，MouseHit ，msg.uMsg，WM_LBUTTONDOWN,注意看EasyX官网文档介绍

	/*下面进行鼠标交互*/
	MOUSEMSG msg;//定义变量，保存鼠标消息
	FlushMouseMsgBuffer();// 清空鼠标消息缓冲区，避免无效鼠标信息带入到正式判断中
	while (true) // 主循环,循环监听鼠标信息
	{

		while (MouseHit())//监听鼠标信息;当有鼠标消息的时候执行,可检测连续的鼠标信息
		{
			msg = GetMouseMsg();//获取鼠标消息

			if (WM_LBUTTONDOWN == msg.uMsg)//判断鼠标信息;鼠标左键按下
			{

				if (msg.x > 460 && msg.x < 820 && msg.y > 600 && msg.y < 635)//鼠标点击特定区域，即按钮所在区域
				{
					Background_1();//调用介绍背景函数
				}

			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

三，EasyX如何做一个句柄窗口，即交互窗口

运用函数：InputBox,MessageBox，
注意：要用wchar_t 定义字符串，具体介绍看下官网的函数文档

InputBox:交互窗口，用户可以输入信息。
MessageBox：信息提醒窗口，展示信息。
代码：

wchar_t s1[50];
InputBox(s1, 20, _T("请输入猜测的数字"), _T("Guess"), 0, 0, false);
MessageBox(NULL, _T("恭喜您猜测正确,金币数加500"), _T("Guess"), MB_OKCANCEL | MB_SETFOREGROUND);
1
2
3

四，EasyX播放音乐（BGM），循环播放

运用函数：mciSendString
注意：
_T(“open+空格+路径+alias+变量名（可变）”),0,0,0
TEXT(“play+空格+变量名+repeat”),0,0,0
如果不加repeat，那么只播放一遍，加上repeat，会循环播放，
路径是不允许存在空格的
头文件为：
#include<mmsystem.h> //bgm
#include<windows.h> //bgm
#pragma comment(lib,“winmm.lib”) //bgm

代码：

	mciSendString(_T("open notangry.mp3 alias music"), 0, 0, 0);
	mciSendString(TEXT("play music repeat"), 0, 0, 0);
1
2

五，C语言运用EasyX做一个拼图游戏

注意：需要用的图片在我的CSDN源码里面
3X3拼图，是有一半几率不能拼出来的，涉及高数知识，不细讲，
但是有算法可以解决，我的代码是运用了这个算法的，不难，很简单

代码：

#include<graphics.h>      // 引用图形库头文件
#include<stdio.h>       
#include<stdlib.h>
#include<conio.h>         //InputBox,MessageBox
#include<time.h>         //随机种子   
#include<mmsystem.h>    //bgm
#include<windows.h>     //bgm
#include "maze.h"       //迷宫
#pragma comment(lib,"winmm.lib")   //bgm

/*全局变量*/
# define IMA_HEIGHT 699  //拼图图片的长
# define IMA_WIDTH 699//拼图图片的宽
# define SIZE 233    //拼图图片大小
# define ROW (IMA_HEIGHT/SIZE)
# define COL (IMA_WIDTH/SIZE)
int y = 0;//拼图判断
IMAGE image;
IMAGE image1;
IMAGE img[ROW * COL];
void JigsawGame()
{
	srand((unsigned)time(NULL));
	GameInit();//分割图片
	MixImg();//打乱图片
	while (1)
	{
		DrawMap();
		GamePlay();
		GameDone();
		if (y == 1)
		{
			break;
		}
	}	
}
void GameInit()
{
	loadimage(&image, L"picture\\pintu.jpg", IMA_HEIGHT, IMA_WIDTH);
	loadimage(&image1, L"picture\\pintu2.jpg", IMA_HEIGHT, IMA_WIDTH);
	putimage(699, 0, &image1);
	SetWorkingImage(&image); //这个函数用于设定当前的绘图设备。设定image为绘图窗口
	int n = 0;
	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			getimage(&img[n++], j * SIZE, i * SIZE, SIZE, SIZE);//得到分割的区域；
		}
	}
	SetWorkingImage(NULL); //把窗口设置为当前的绘图工作区，为默认绘图窗口，即默认，相当于重开
	//将最后一块图片换成空格图片
	loadimage(&img[ROW * COL - 1], L"blank.jpg", SIZE, SIZE);//空白
	n = 0;
	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			arr[i][j] = n;
			n++;
		}
	}

}
void DrawMap()
{
	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			putimage(j * SIZE, i * SIZE, &img[arr[i][j]]);
		}
	}
}
void GamePlay()
{
	int Blank_i, Blank_j;//空白图片的列，行坐标；
	int Mouse_i, Mouse_j;//鼠标的列，行坐标；

	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			if (arr[i][j] == ROW * COL - 1)
			{
				Blank_i = i;
				Blank_j = j;
			}
		}
	}
	MOUSEMSG msg = { 0 };//定义一个鼠标消息；
	msg = GetMouseMsg();
	switch (msg.uMsg)
	{
	case WM_LBUTTONDOWN:
		//获取点击图片的坐标；
		Mouse_i = msg.y / SIZE;
		Mouse_j = msg.x / SIZE;
		if (Mouse_i == Blank_i && Mouse_j == Blank_j - 1 ||
			Mouse_i == Blank_i && Mouse_j == Blank_j + 1 ||
			Mouse_j == Blank_j && Mouse_i == Blank_i - 1 ||
			Mouse_j == Blank_j && Mouse_i == Blank_i + 1
			)
		{

			arr[Blank_i][Blank_j] = arr[Mouse_i][Mouse_j];
			arr[Mouse_i][Mouse_j] = ROW * COL - 1;
		}
		else if (msg.x > 1139 && msg.x < 1329 && msg.y > 116 && msg.y < 170)
		{
			JigsawGame();
		}
		break;
	}
}
void MixImg()
{
	// 0~ROW*COL-1的数;
	int a[ROW * COL - 1];
	int i, j;
	for (i = 0; i < ROW * COL - 1; i++)
	{
		int n = rand() % (ROW * COL - 1);
		for (j = 0; j < i; j++)
		{
			if (a[j] == n) {
				i--;
				break;
			}
		}
		if (j >= i)
			a[i] = n;
	}
	int cnt = 0;
	for (i = 0; i < ROW * COL - 1; i++)
		for (j = i + 1; j < ROW * COL - 1; j++)
		{
			if (a[i] > a[j])     //排除空白块0
				cnt++;
		}
	if (cnt % 2)     //奇排列则无解
	{
		MixImg();
	}

	int n = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			arr[i][j] = a[n];
			arr[ROW - 1][COL - 1] = ROW * COL - 1;
			n++;
		}
	}


}
void GameDone()
{
	int i, j;
	int n = 0;
	int count = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			if (arr[i][j] == n)
			{
				count++;
			}
			n++;
		}
	}
	if (count == ROW * COL)
	{
		y = 1;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

六，C++语言运用EasyX做一个迷宫游戏

EasyX做一个迷宫游戏
代码：

#include<graphics.h> 
#include <vector>
#include <stack>
#include<conio.h>
using std::stack;				// 使用STL的栈
using std::vector;				// 使用STL的数组容器
// 游戏信息
#define WIN_WIDTH	1366			// 窗口的宽度(单位：像素)
#define WIN_HEIGHT	700			// 窗口的高度(单位：像素)
// !!注：由于随机生成算法的原因，地图宽高只能为奇数
#define GAME_WIDTH	21			// 地图的宽度(单位：块)
#define GAME_HEIGHT	21			// 地图的高度(单位：块)
#define WALL		1			// 墙壁的数字标记
#define GROUND		0			// 地面的数字标记
#define FILLSTATE	2			// 加油站的数字标记
#define ENDPOS		3			// 终点的数字标记
#define MAXVIEW		5.0			// 最大的视野
#define MINVIEW		1			// 最小的视野
#define FILLNUM		10			// 加油站的数量
#define DARKTIME	8			// 视野下降1图块所需的时间
// 全局变量列表
int		g_BlockSize;			// 块大小
int		g_GameMap[GAME_HEIGHT][GAME_WIDTH];	// 地图(宽高单位为块)
POINT	g_EndPos;				// 终点位置
POINT   g_PlayerPos;			// 玩家在地图上的位置
POINT	g_CameraPos;			// 摄像机(屏幕左上角)在地图上的位置
IMAGE	g_MapImage;				// 地图的图片(由于地图是固定的，在不改变缩放的情况下只需要绘制一次)
double	g_ViewArray;			// 视野
UINT	g_BeginTime;			// 游戏开始时的时间
UINT	g_LastFillTime;			// 上次为油灯加油的时间

void initGame();				// 初始化游戏
void endGame();					// 结束游戏
void draw();					// 绘制函数
bool upDate();					// 数据更新函数
void absDelay(int delay);		// 绝对延迟

bool canMove(POINT pos);		// 判断某个位置是否可以移动
void computeCameraPos();		// 计算摄像机在地图上的位置
void rePaintMap();				// 重绘地图

void drawWall(POINT pos);		// 绘制墙壁图块的函数
void drawGround(POINT pos);		// 绘制地面图块的函数
void drawFillState(POINT pos);	// 绘制油灯图块的函数
void drawEndPos(POINT pos);		// 绘制终点
void drawPlayer();				// 绘制人物的函数
void drawView();				// 绘制视野

int maze()
{
	initGame();

	while (1)
	{
		if (!upDate()) break;	// 更新
		draw();					// 绘制
		absDelay(16);			// 绝对延迟 16 毫秒，控制每秒 60 帧
	}

	endGame();
	return 0;
}

void initGame()
{
	g_BlockSize = 32;		// 初始图块大小为 32 个像素
	srand(GetTickCount());	// 初始化随机数生成

	// 初始化间隔室
	for (int i = 0; i < GAME_HEIGHT; i++)
	{
		for (int j = 0; j < GAME_WIDTH; j++)
		{
			if (i % 2 == 0 || j % 2 == 0)	// 奇数行奇数列设为墙壁
				g_GameMap[i][j] = WALL;
			else
				g_GameMap[i][j] = GROUND;
		}
	}


	// 随机生成地图(使用深度优先遍历)
	stack<POINT> stepStack;		// 步骤栈
	vector<POINT>  stepPoint;	// 四周的点
	POINT nowPoint;				// 当前步的所在点
	stepStack.push({ 1,1 });	// 写入初始点 (1,1) 作为起点
	nowPoint = { 1,1 };
	g_GameMap[1][1] = 0xFFFF;	// 标记这个点
	while (!stepStack.empty())	// 只要步骤栈不空就继续循环
	{
		// 得到四周的点
		POINT tempPoint;
		for (int i = -1; i <= 1; i += 2)
		{
			tempPoint = { nowPoint.x,nowPoint.y + i * 2 };	// 计算点
			// 判断坐标是否合法
			if (tempPoint.x >= 0 && tempPoint.x <= GAME_WIDTH - 1 &&
				tempPoint.y >= 0 && tempPoint.y <= GAME_HEIGHT - 1 &&
				g_GameMap[tempPoint.y][tempPoint.x] != 0xFFFF)
			{
				stepPoint.push_back(tempPoint);
			}
			tempPoint = { nowPoint.x + i * 2 ,nowPoint.y };	// 计算点
			// 判断坐标是否合法
			if (tempPoint.x >= 0 && tempPoint.x <= GAME_WIDTH - 1 &&
				tempPoint.y >= 0 && tempPoint.y <= GAME_HEIGHT - 1 &&
				g_GameMap[tempPoint.y][tempPoint.x] != 0xFFFF)
			{
				stepPoint.push_back(tempPoint);
			}
		}

		// 根据周围点的量选择操作
		if (stepPoint.empty())				// 如果周围点都被遍历过了
		{
			stepStack.pop();				// 出栈当前点
			if (!stepStack.empty())
				nowPoint = stepStack.top();	// 更新当前点
		}
		else
		{
			stepStack.push(stepPoint[rand() % stepPoint.size()]);	// 入栈当前点
			g_GameMap[(nowPoint.y + stepStack.top().y) / 2][(nowPoint.x + stepStack.top().x) / 2] = 0;	// 打通墙壁
			nowPoint = stepStack.top();		// 更新当前点点
			g_GameMap[nowPoint.y][nowPoint.x] = 0xFFFF;				// 标记当前
		}
		stepPoint.clear();					// 清空周围点以便下一次循环
	}

	// 清洗标记点
	for (int i = 0; i < GAME_HEIGHT; i++)
	{
		for (int j = 0; j < GAME_WIDTH; j++)
		{
			if (g_GameMap[i][j] == 0xFFFF)
				g_GameMap[i][j] = 0;
		}
	}

	// 随机生成加油站的位置
	for (int i = 0; i < FILLNUM; i++)
	{
		POINT fillPoint = { rand() % GAME_WIDTH,rand() % GAME_HEIGHT };
		// 保证在空地生成加油站
		while (g_GameMap[fillPoint.y][fillPoint.x] != GROUND)
			fillPoint = { rand() % GAME_WIDTH,rand() % GAME_HEIGHT };
		// 标记油灯
		g_GameMap[fillPoint.y][fillPoint.x] = FILLSTATE;
	}

	g_GameMap[GAME_HEIGHT - 2][GAME_WIDTH - 2] = ENDPOS;		// 标记终点
	g_EndPos = { GAME_WIDTH - 2,GAME_HEIGHT - 2 };				// 确定终点位置
	g_ViewArray = MAXVIEW;				// 初始视野是最大的
	g_BeginTime = GetTickCount();		// 开始计时
	g_LastFillTime = GetTickCount();	// 油灯加油的时间
	rePaintMap();						// 绘制地图
	g_PlayerPos = { g_BlockSize * 3 / 2,g_BlockSize * 3 / 2 };	// 初始化人的位置
	computeCameraPos();					// 计算摄像机的位置
	initgraph(WIN_WIDTH, WIN_HEIGHT);	// 初始化画布
	setbkmode(TRANSPARENT);				// 设置背景为透明
	BeginBatchDraw();					// 开始缓冲绘制
}

void endGame()
{
	EndBatchDraw();						// 结束缓冲绘制						
}

void draw()
{
	// 清空设备
	cleardevice();
	// 绘制视野
	drawView();
	// 绘制人
	drawPlayer();
	// 绘制时间
	TCHAR timeStr[256];
	int loseTime = GetTickCount() - g_BeginTime;	// 计算流失的时间
	_stprintf_s(timeStr, _T("找碎片已用时:%02d:%02d"), loseTime / 1000 / 60, loseTime / 1000 % 60);
	settextcolor(RGB(140, 140, 140));
	outtextxy((WIN_WIDTH - textwidth(timeStr)) / 2, 3, timeStr);

	FlushBatchDraw();	// 刷新屏幕
}

bool upDate()
{
	POINT nextPos = g_PlayerPos;		// 下一个位置

	// 计算下一个位置
	if (GetKeyState(VK_UP) & 0x8000)	nextPos.y -= 2;
	if (GetKeyState(VK_DOWN) & 0x8000)	nextPos.y += 2;
	if (GetKeyState(VK_LEFT) & 0x8000)	nextPos.x -= 2;
	if (GetKeyState(VK_RIGHT) & 0x8000)	nextPos.x += 2;

	// 如果下一个位置不合法
	if (!canMove(nextPos))
	{
		if (canMove({ g_PlayerPos.x, nextPos.y }))		// y 轴移动合法
			nextPos = { g_PlayerPos.x, nextPos.y };
		else if (canMove({ nextPos.x, g_PlayerPos.y }))	// x 轴移动合法
			nextPos = { nextPos.x, g_PlayerPos.y };
		else											// 都不合法
			nextPos = g_PlayerPos;
	}

	// 如果是油灯则更新时间
	if (g_GameMap[nextPos.y / g_BlockSize][nextPos.x / g_BlockSize] == FILLSTATE)
		g_LastFillTime = GetTickCount();
	// 如果是终点则通关
	else if (g_GameMap[nextPos.y / g_BlockSize][nextPos.x / g_BlockSize] == ENDPOS)
	{
		FlushBatchDraw();
		return false;
	}
	g_PlayerPos = nextPos;						// 更新位置
	computeCameraPos();							// 计算摄像机的位置

	// 根据时间缩减视野
	static unsigned int lastTime = GetTickCount();
	int loseTime = GetTickCount() - g_LastFillTime;			// 计算流失的时间
	g_ViewArray = MAXVIEW - loseTime / 1000.0 / DARKTIME;	// 每一段时间油灯的照明力会下降一个图块
	if (g_ViewArray < MINVIEW) g_ViewArray = MINVIEW;

	// 处理鼠标消息
	MOUSEMSG mouseMsg;							// 鼠标信息
	int lastBlockSize = g_BlockSize;			// 保存原本的大小
	while (MouseHit())
	{
		mouseMsg = GetMouseMsg();
		if (mouseMsg.uMsg == WM_MOUSEWHEEL)		// 滚轮消息
		{
			g_BlockSize += mouseMsg.wheel / 120;
		}
	}

	// 如果没有滚轮消息就退出
	if (lastBlockSize == g_BlockSize) return true;
	// 处理滚轮消息
	if (g_BlockSize >= 10 && g_BlockSize <= 50)	// 块大小没有达到极限值
	{
		// 保证缩放后的地图不会比窗口小
		if (GAME_WIDTH * g_BlockSize < WIN_WIDTH ||
			GAME_HEIGHT * g_BlockSize < WIN_HEIGHT)
			g_BlockSize = lastBlockSize;
		rePaintMap();							// 重绘地图
		// 重新计算玩家在地图上的位置
		POINT mapPos = { g_PlayerPos.x / lastBlockSize,g_PlayerPos.y / lastBlockSize };	// 计算在地图上的位置
		g_PlayerPos.x = mapPos.x * g_BlockSize + g_BlockSize / 2;	// 计算映射后的位置
		g_PlayerPos.y = mapPos.y * g_BlockSize + g_BlockSize / 2;	// 计算映射后的位置
		computeCameraPos();						// 重新计算摄像机位置
	}
	// 保证图块不会过大和过小
	if (g_BlockSize < 10) g_BlockSize = 10;
	if (g_BlockSize > 50) g_BlockSize = 50;

	return true;
}

void absDelay(int delay)
{
	static int curtime = GetTickCount();
	static int pretime = GetTickCount();
	while (curtime - pretime < delay)
	{
		curtime = GetTickCount();
		Sleep(1);
	}
	pretime = curtime;
}

bool canMove(POINT pos)
{
	// 只要外接矩形的四个顶点不在墙壁内就必定合法
	return	g_GameMap[(pos.y - 3) / g_BlockSize][(pos.x - 3) / g_BlockSize] != WALL &&
		g_GameMap[(pos.y + 3) / g_BlockSize][(pos.x + 3) / g_BlockSize] != WALL &&
		g_GameMap[(pos.y - 3) / g_BlockSize][(pos.x + 3) / g_BlockSize] != WALL &&
		g_GameMap[(pos.y + 3) / g_BlockSize][(pos.x - 3) / g_BlockSize] != WALL;
}

void computeCameraPos()
{
	// 以人物位置为中心计算摄像机的理论位置
	g_CameraPos.x = g_PlayerPos.x - WIN_WIDTH / 2;
	g_CameraPos.y = g_PlayerPos.y - WIN_HEIGHT / 2;

	// 防止摄像机越界
	if (g_CameraPos.x < 0)										g_CameraPos.x = 0;
	if (g_CameraPos.y < 0)										g_CameraPos.y = 0;
	if (g_CameraPos.x > GAME_WIDTH * g_BlockSize - WIN_WIDTH)	g_CameraPos.x = GAME_WIDTH * g_BlockSize - WIN_WIDTH;
	if (g_CameraPos.y > GAME_HEIGHT * g_BlockSize - WIN_HEIGHT)	g_CameraPos.y = GAME_HEIGHT * g_BlockSize - WIN_HEIGHT;
}

void rePaintMap()
{
	g_MapImage.Resize(GAME_WIDTH * g_BlockSize, GAME_HEIGHT * g_BlockSize);	// 重置地图图片大小
	SetWorkingImage(&g_MapImage);								// 设置地图图片为当前工作图片
	for (int i = 0; i < GAME_HEIGHT; i++)
	{
		for (int j = 0; j < GAME_WIDTH; j++)
		{
			switch (g_GameMap[i][j])
			{
			case WALL:
				drawWall({ j * g_BlockSize,i * g_BlockSize });		// 绘制墙壁
				break;
			case FILLSTATE:
				drawFillState({ j * g_BlockSize,i * g_BlockSize });	// 绘制加油站
				break;
			case GROUND:
				drawGround({ j * g_BlockSize,i * g_BlockSize });	// 绘制地面
				break;
			case ENDPOS:
				drawEndPos({ j * g_BlockSize,i * g_BlockSize });
				break;
			}
		}
	}
	SetWorkingImage();	// 复位工作图片
}

void drawWall(POINT pos)
{
	setfillcolor(RGB(254, 109, 19));
	solidrectangle(pos.x, pos.y, pos.x + g_BlockSize, pos.y + g_BlockSize);
}

void drawGround(POINT pos)
{
	setfillcolor(RGB(255, 255, 255));
	solidrectangle(pos.x, pos.y, pos.x + g_BlockSize, pos.y + g_BlockSize);
}

void drawFillState(POINT pos)
{
	drawGround(pos);

	// 绘制圆角矩形
	pos.x += g_BlockSize / 5;
	pos.y += g_BlockSize / 5;
	setfillcolor(RGB(252, 213, 11));
	solidroundrect(pos.x, pos.y, pos.x + g_BlockSize / 5 * 3, pos.y + g_BlockSize / 5 * 3, g_BlockSize / 8, g_BlockSize / 8);
}

void drawEndPos(POINT pos)
{
	drawGround(pos);

	// 绘制圆角矩形
	pos.x += g_BlockSize / 5;
	pos.y += g_BlockSize / 5;
	setfillcolor(RGB(87, 116, 48));
	solidroundrect(pos.x, pos.y, pos.x + g_BlockSize / 5 * 3, pos.y + g_BlockSize / 5 * 3, g_BlockSize / 8, g_BlockSize / 8);
}

void drawPlayer()
{
	setfillcolor(RGB(252, 213, 11));
	solidcircle(g_PlayerPos.x - g_CameraPos.x, g_PlayerPos.y - g_CameraPos.y, 3);
}

void drawView()
{
	// 锁定视野
	HRGN viewArr;
	int r = int(g_BlockSize * g_ViewArray + 0.5);	// 计算视野半径
	POINT orgin = g_PlayerPos;
	orgin.x -= g_CameraPos.x;						// 计算在屏幕上的位置
	orgin.y -= g_CameraPos.y;						// 计算在屏幕上的位置
	viewArr = CreateEllipticRgn(orgin.x - r, orgin.y - r, orgin.x + r, orgin.y + r);	// 创建一个圆形的区域
	setcliprgn(viewArr);							// 锁定区域

	// 绘制地图
	putimage(0, 0, WIN_WIDTH, WIN_HEIGHT, &g_MapImage, g_CameraPos.x, g_CameraPos.y);

	// 删除区域
	DeleteObject(viewArr);
	// 消除区域
	setcliprgn(NULL);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382

七，C语言运用EasyX做一个猜数游戏

EasyX做一个猜数游戏

不难，简单，加上文章开头的头文件，还有需要的图片，注意路径要正确

代码：

void Guess()
{   
	wchar_t s1[50];
	wchar_t s[20];
	loadimage(&guess, L"picture\\guess.jpg");
	putimage(0, 0, &guess);
	MOUSEMSG msg;//定义变量，保存鼠标消息
	FlushMouseMsgBuffer();// 清空鼠标消息缓冲区，避免无效鼠标信息带入到正式判断中
	while (true) // 主循环,循环监听鼠标信息
	{
		while (MouseHit())	//监听鼠标信息;当有鼠标消息的时候执行,可检测连续的鼠标信息
		{
			msg = GetMouseMsg();//获取鼠标消息
			if (WM_LBUTTONDOWN == msg.uMsg)//判断鼠标信息;鼠标左键按下
			{
				if (msg.x > 1000 && msg.x < 1200 && msg.y > 70 && msg.y < 130)//鼠标点击特定区域，即ENTER按钮所在区域
				{
					money = money - 200;
					int m = rand() % 100;
					int n;
					_itow_s(m, s, 10, 10);//int 转换成 wchar_t
					for (n = 0; n < 7; n++)
					{
						InputBox(s1, 20, _T("请输入猜测的数字"), _T("Guess"), 0, 0, false);
						int x = _wtoi(s1);//wchar_t 转换成 int
						if (x == m)
						{
							MessageBox(NULL, _T("恭喜您猜测正确,金币数加500"), _T("Guess"), MB_OKCANCEL | MB_SETFOREGROUND);
							money = money + 700;
							break;
						}
						else
						{
							if (x > m)
								MessageBox(NULL, _T("数字猜测大了"), _T("Guess"), MB_OKCANCEL | MB_SETFOREGROUND);
							else
								MessageBox(NULL, _T("数字猜测小了"), _T("Guess"), MB_OKCANCEL | MB_SETFOREGROUND);
						}
					}
					if (n == 7)
						MessageBox(NULL, _T("不好意思，您5次都没猜对，金币数扣200"), _T("Guess"), MB_OKCANCEL | MB_SETFOREGROUND);
				}
				if (msg.x > 1010 && msg.x < 1200 && msg.y > 460 && msg.y < 525)//鼠标点击特定区域，即ENTER按钮所在区域
				{
					Adult_background1();
				}

			}
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

八，部分代码展示

#include<graphics.h>      // 引用图形库头文件
#include<stdio.h>       
#include<stdlib.h>
#include<conio.h>         //InputBox,MessageBox
#include<time.h>         //随机种子   
#include<mmsystem.h>    //bgm
#include<windows.h>     //bgm
#include "maze.h"       //迷宫
#pragma comment(lib,"winmm.lib")   //bgm

/*全局变量*/
# define IMA_HEIGHT 699  //拼图图片的长
# define IMA_WIDTH 699//拼图图片的宽
# define SIZE 233    //拼图图片大小
# define ROW (IMA_HEIGHT/SIZE)
# define COL (IMA_WIDTH/SIZE)

int num = 0;//记录碎片个数，初始化为0
int money = 1000;//记录金币个数，初始化为1000
int sum = 2;//赌场商店最多可以买的碎片个数
int x1 = 1;//每个猜数游戏只能获得一次碎片
int x2 = 1;//每个猜数游戏只能获得一次碎片
int x3 = 1;//每个猜数游戏只能获得一次碎片
int m = 1;//迷宫只能获得一次碎片
int y = 0;//拼图判断

/*定义图片*/
IMAGE start;//开始
IMAGE start_button;
IMAGE background1;//背景1
IMAGE background2;//背景2
IMAGE background3;//背景3
IMAGE background4;//背景4
IMAGE background5;//背景5
IMAGE background6;//背景6
IMAGE time1;//时空选择
IMAGE childbackground;//童年背景
IMAGE youthbackground;//青春背景
IMAGE adultbackground;//成年背景
IMAGE adultbackground1;//商店与猜数
IMAGE shop;
IMAGE guess;
IMAGE get;
IMAGE jigsawGame;
IMAGE image;
IMAGE image1;
IMAGE img[ROW * COL];
IMAGE game1;
IMAGE game2;
IMAGE game3;
IMAGE end1;
IMAGE end1_1;
IMAGE end1_2;
IMAGE end2;
IMAGE end2_1;
IMAGE end2_2;
IMAGE end3;

int arr[ROW][COL];
bool State = false;
void Welcome();//开始界面 
void Get();//获得碎片成功的界面
void Background_1();//介绍背景
void Background_2();
void Background_3();
void Background_4();
void Background_5();
void Background_6();

void Time();//时空选择
void Childhood_background();//童年时期背景
void Youth_background();//青春期背景
void Adult_background();//成年时期背景
void Adult_background1();//商店与猜数游戏

void Shop();//商店函数
void Guess();//猜数游戏

void JigsawGame();//拼图游戏
void GameInit();//初始化游戏
void DrawMap();//画地图
void GamePlay();//玩游戏:1、鼠标点击图片2、点击与空白相邻的图片时，会和空白图片交换；
void MixImg(); //打乱图片顺序；
void GameDone();//完成游戏

void Game1();//文字猜谜游戏1；
void Game2();//文字猜谜游戏2；
void Game3();//文字猜谜游戏3；

void End();//结局
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

九，完整代码

文字解谜游戏：梦境寻踪
提取码：yfc6
说明：图片都是用ps自己制作的，切不可更改图片命名，否则会导致程序无法运行，因为图片命名和代码要保持一致。

十，要点

1、创建项目：新建-项目-空项目-右键“源文件”-添加-新建项-C++文件
2、编码字符集：unicode字符集

3.将图片资源直接导入到所命名的文件夹中，注意不要将图片打包文件夹后再放入，要直接将图片导入对应文件夹。
4.程序中要多次用到图形库的函数，建议刚接触的初学者查看EasyX安装时附带的官方帮助文档，也可以参考我分享的源代码。但是考虑到帮助文档内容较少，对函数的用法介绍较少，下面分享一个关于EasyX图形库详细函数用法介绍的文档。
EasyX文档
提取码：yfc6