Devc++ Easyx 实现 瓦片地图编辑数据导入游戏

导出的DLC 直接放入 exe 同文件夹下即可自动读取。

cpp 复制代码
// 程序:DLC 自动读取加载框架示例
// 作者:民用级脑的研发记录
// 邮箱:1309602336@qq.com
// 编译环境:Devc++/VC 2010/Visual Studio 2022,EasyX_20220901/Easyx_2023 大暑版
// 编写日期:2024-2-22
//
#undef UNICODE
#undef _UNICODE
#pragma warning(disable : 4996)		// VS2022 对某些函数警告,但是为了方便移植,就无视这些警告,这样 Devc++ VS2022 都能跑
#include <graphics.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <direct.h>
// 初始化地图
int** initmap(int wide, int high);
// 从默认文件夹中读取自定义图片
void loadfile(char* DLC, IMAGE*** pentablev2);
// 加载自定义图片
void loadfile_scanf(char* dirname, char* next, char* kind, IMAGE** pentablev2);
// 导入游戏地图贴图数据
void loadgamemap(int** map, int* gamemapi, int* gamemapj, IMAGE* pentable, IMAGE*** pentablev2, int* pixnum, int* imagenum);
// 刷新网格缓冲区
inline void freshmesh(IMAGE* bkmesh, int** map, IMAGE* pentable, IMAGE*** pentablev2, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum);
// 在屏幕上显示缓冲区
inline void showbkmesh(IMAGE* bkmesh, int bkmeshdeskx, int bkmeshdesky);
// 在纹理映射函数中产生的图片中截图,但此为演示参数作用,此处并未优化。
inline void freshbk(IMAGE* bk, IMAGE* bkmesh, int gamex, int gamey, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum);
// 在屏幕显示截图
inline void showbk(IMAGE* bk, int bkdeskx, int bkdesky);
// 检查边界
inline void checkboundary(int* bkgameleft, int* bkgametop, int gamelimitright, int gamelimitbuttom, int* bkmeshgameleft, int* bkmeshgametop, int* meshlimitright, int* meshlimitbuttom, int move, int size);
// 实时渐变色小动画
inline void animation(int chararcterflag, int bkgameleft, int bkgametop, int bkmeshgameleft, int bkmeshgametop, int bkmeshdeskleft, int bkmeshdesktop);
int main()
{
	initgraph(1600, 800);
	setbkcolor(GREEN);
	cleardevice();
	IMAGE* bk;									// 背景图片寄存区
	bk = new IMAGE(270, 270);
	IMAGE* bkmesh;								// 背景图片采样区
	bkmesh = new IMAGE(270 * 3, 270 * 3);
	int** map;									// 游戏大地图数组,记录着整个游戏背景的贴图信息,而在运行过程中,选取部分区域的数字,对照序号与贴图,实现游戏背景绘制。其余没有选中的区域就是压缩的空间。
	int pixnum;									// 一个正方形瓦片的边长。单位:像素
	int bkgameleft;								// 背景图片寄存区左上角坐标,是在游戏里的像素坐标。(0,0)可以理解为游戏大地图的左上角顶点。
	int bkgametop;
	int bkmeshgameleft;							// 背景图片采样区左上角坐标,是在游戏里的像素坐标。
	int bkmeshgametop;
	int bkmeshmapi;								// 背景图片采样区左上角所对应的 map 数组序号。从 map[0][0]开始,按照 map[i][j],其中 bkmeshmapi=bkmeshtop/pixnum
	int bkmeshmapj;
	int bkdeskleft;								// 规定在屏幕上显示游戏背景寄存区,此处记录其左上角在屏幕上的像素坐标
	int bkdesktop;
	int bkmeshdeskleft;							// 规定在屏幕上显示游戏背景采样区,此处记录其左上角在屏幕上的像素坐标
	int bkmeshdesktop;
	pixnum = 30;								// 进行初始化,规定各位置具体数字
	bkdeskleft = 200;							// 游戏背景左上角将会在屏幕的(200,200) 处
	bkdesktop = 200;
	bkgameleft = 0;								// 由于 bkgame 控制 mesh 坐标移动,(0,0)则游戏背景完全在当前采样区移动
	bkgametop = 0;
	bkmeshdeskleft = 700;						// 游戏背景缓冲区左上角将会在屏幕的(700,0)处
	bkmeshdesktop = 0;
	bkmeshgameleft = 0;
	bkmeshgametop = 0;
	int meshlimitright;							// 使用变量暂存边界,不用每次来回计算边界
	int meshlimitbuttom;
	meshlimitright = 270;							// 和寄存区一样大,把寄存区限制在一个九宫格中心,如果越出九宫格,九宫格整体平移
	meshlimitbuttom = 270;
	bkmeshmapi = bkmeshgametop / pixnum;
	bkmeshmapj = bkmeshgameleft / pixnum;
	int mapi;										// 读取 DLC 文件,需要变量记录循环次数,单位 瓦片贴图个数
	int mapj;
	int safemapi;									// 一个安全的贴图范围,避免阅读超过 10000 导致的越界闪退问题。
	int safemapj;
	int gamelimitright;								// 用于减少比较时的计算,存储边界范围
	int gamelimitbuttom;
	safemapi = 70;									// 注意导出的是左上角开始的 100*100 部分,如果绘制出界,保存不了,需要改这一行和下一行的数字
	safemapj = 70;
	gamelimitright = pixnum * safemapi;
	gamelimitbuttom = pixnum * safemapj;
	mapi = 300;
	mapj = 300;
	int imagenum;									// 调色板数量上限,用于文件读取控制循环次数
	IMAGE* pentable;								// 调色板其实就是贴图数组
	imagenum = 10;
	int pentablev2high;								// 自定义贴图的容量大小
	int pentablev2wide;
	pentablev2high = 10;
	pentablev2wide = 4;
	IMAGE*** pentablev2;
	map = initmap(mapi, mapj);
	pentable = new IMAGE[imagenum];
	for (int i = 0; i < imagenum; i++)
	{
		pentable[i] = IMAGE(30, 30);
		SetWorkingImage(&pentable[i]);					// 给调色板绘制颜色
		setfillcolor(RGB(i * 20, i * 20, i * 20));		// 这里初始化调色盘的颜色
		fillrectangle(-1, -1, pixnum, pixnum);			// 在调色板上绘制颜色(纹理)要从 -1,-1 开始绘制,把边框画到外部,不保留边框。
	}
	pentablev2 = new IMAGE * *[pentablev2wide];
	for (int i = 0; i < pentablev2wide; i++)
		pentablev2[i] = new IMAGE * [pentablev2high];
	for (int i = 0; i < pentablev2wide; i++)
		for (int j = 0; j < pentablev2high; j++)
			pentablev2[i][j] = NULL;

	loadgamemap(map, &safemapi, &safemapj, pentable, pentablev2, &pixnum, &imagenum);				// 加载游戏
	freshmesh(bkmesh, map, pentable, pentablev2, bkmeshmapi, bkmeshmapj, 27, pixnum);
	showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
	freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, pixnum);
	showbk(bk, bkdeskleft, bkdesktop);
	int moveflag;															// 是否键盘控制移动
	int flag_x;																// 记录位移
	int flag_y;
	int speed;																// 键盘控制视口的移动速度
	speed = 5;
	flag_x = 0;
	flag_y = 0;
	moveflag = 0;
	int oldbkmeshgamex;														// 判断是否需要刷新 bkmesh 网格
	int oldbkmeshgamey;
	oldbkmeshgamex = -1;
	oldbkmeshgamey = -1;
	int characterflag;														// 用于按键时游戏小人的颜色变化
	characterflag = 5;
	ExMessage m;
	while (1)
	{
		while (peekmessage(&m, EX_KEY | EX_MOUSE))
		{
			switch (m.message)
			{
			case WM_KEYDOWN:
				switch (m.vkcode)				// 键盘移动控制
				{
				case 0x41:						// A
					if (flag_x - speed > -10)	// 限制范围,减少内存读写
						flag_x -= speed;
					characterflag = 1;
					break;
				case 0x57:						// W
					if (flag_y - speed > -10)
						flag_y -= speed;
					characterflag = 2;
					break;
				case 0x44:						// D
					if (flag_x + speed < 10)
						flag_x += speed;
					characterflag = 3;
					break;
				case 0x53:						// S
					moveflag = 1;
					if (flag_y + speed < 10)
						flag_y += speed;
					characterflag = 4;
					break;
				}
				break;
			case WM_KEYUP:
				switch (m.vkcode)
				{
				case 0x41:						// A
					flag_x = 0;
					break;
				case 0x57:						// W
					flag_y = 0;
					break;
				case 0x44:						// D
					flag_x = 0;
					break;
				case 0x53:						// S
					flag_y = 0;
					break;
				}
				if (flag_x == 0 && flag_y == 0)
					characterflag = 5;
				break;
			}
		}


		if (flag_x != 0 || flag_y != 0)
		{
			moveflag = 1;
			bkgameleft += flag_x;
			bkgametop += flag_y;
		}
		else
		{
			moveflag = 0;
		}

		if (moveflag == 1)
		{
			checkboundary(&bkgameleft, &bkgametop, gamelimitright, gamelimitbuttom, &bkmeshgameleft, &bkmeshgametop, &meshlimitright, &meshlimitbuttom, 270, 540);
			bkmeshmapi = bkmeshgametop / pixnum;
			bkmeshmapj = bkmeshgameleft / pixnum;
			if (oldbkmeshgamex != bkmeshgameleft || oldbkmeshgamey != bkmeshgametop)										// 判断是否更新采样区
			{
				freshmesh(bkmesh, map, pentable, pentablev2, bkmeshmapi, bkmeshmapj, 27, 30);
				oldbkmeshgamex = bkmeshgameleft;
				oldbkmeshgamey = bkmeshgametop;
				showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
			}
			freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, 30);
			showbk(bk, bkdeskleft, bkdesktop);
		}

		animation(characterflag, bkgameleft, bkgametop, bkmeshgameleft, bkmeshgametop, bkmeshdeskleft, bkmeshdesktop);		// 小方块动画
		Sleep(1);
	}

	return 0;
}
// 初始化游戏地图
int** initmap(int wide, int high)
{
	int** map = new int* [high];					// 二维数组动态初始化,先给二级指针挂上一个长度为 10 的指针数组
	for (int i = 0; i < high; i++)
	{
		map[i] = new int[wide];						// 然后数组里的每个指针都挂上一个长度为 10 的 int 类型数组
	}
	for (int i = 0; i < high; i++)
	{
		for (int j = 0; j < wide; j++)
		{
			map[i][j] = -1;							// 初始化游戏大地图 map 的参数,参数 1 默认黑色
		}
	}
	return map;
}
// 读取 DLC 继续开发
void loadgamemap(int** map, int* gamemapi, int* gamemapj, IMAGE* pentable, IMAGE*** pentablev2, int* pixnum, int* imagenum)
{
	FILE* fp;
	int i = 0;
	int j = 0;
	char dirpath[400] = { '\0' };
	char filepath[400] = { '\0' };
	for (i = 0; i < 100; i++)
	{
		sprintf(dirpath, "DLC%d", i);
		if (access(dirpath, 0) == 0) 										// 检查 DLC 是否存在,存在为 0
		{
			break;
		}
	}
	if (i == 100)															// 100 次查找失败,则返回,不再读取
		return;
	char filename[400] = "gamemap.txt";
	const char* next = "./";
	strcat(filepath, dirpath);
	strcat(filepath, next);
	strcat(filepath, filename);
	fp = fopen(filepath, "r");												// 读取 .txt 文件
	fscanf(fp, "注意此导出的游戏文件为按键 F1 后自动生成 修改汉语字符或者英文字符 或导致该 .txt 文件不可读取\n");
	fscanf(fp, "warning this saved gamefile is automatically create after F1 pressed change Chinesse character or English character lead to read failed");
	fscanf(fp, "pixnum %d\n", pixnum);										// 正方形瓦片贴图边长信息:单位:像素
	fscanf(fp, "imagenum %d\n", imagenum);									// 瓦片个数
	char imageindix[400] = { '\0' };
	char imagepath[400] = { '\0' };
	for (i = 0; i < *imagenum; i++)
	{
		fscanf(fp, "%s\n", imageindix);
		strcpy(imagepath, dirpath);
		strcat(imagepath, next);
		strcat(imagepath, imageindix);
		loadimage(&pentable[i], imagepath, *pixnum, *pixnum, false);		// 批量导入贴图
	}
	fscanf(fp, "gamemapi %d gamemapj %d\n", gamemapi, gamemapj);
	for (i = 0; i < *gamemapi; i++)
	{
		fscanf(fp, "%d", &map[i][j]);
		for (j = 0; j < *gamemapj; j++)
		{
			fscanf(fp, " %d", &map[i][j]);
		}
		fscanf(fp, "\n");
	}
	fclose(fp);
	printf("导入 map 部分正常\n");
	loadfile(dirpath, pentablev2);
}
// 从默认文件夹中读取自定义图片
void loadfile(char* DLC, IMAGE*** pentablev2)
{
	char brick[100] = "aa_birck_6_family";
	char ground[100] = "ab_ground_7_family";
	char change[100] = "ac_change_8_family";
	char trick[100] = "ad_trick_9_family";
	char next[100] = "./";
	char png[100] = "*.png";
	char dirpath[100] = {};
	strcpy(dirpath, DLC);
	strcat(dirpath, next);
	strcat(dirpath, brick);
	loadfile_scanf(dirpath, next, png, pentablev2[0]);								// 加载用于当砖头类型的图片
	strcpy(dirpath, DLC);
	strcat(dirpath, next);
	strcat(dirpath, ground);
	loadfile_scanf(dirpath, next, png, pentablev2[1]);
	strcpy(dirpath, DLC);
	strcat(dirpath, next);
	strcat(dirpath, change);
	loadfile_scanf(dirpath, next, png, pentablev2[2]);
	strcpy(dirpath, DLC);
	strcat(dirpath, next);
	strcat(dirpath, trick);
	loadfile_scanf(dirpath, next, png, pentablev2[3]);
}
// 加载自定义图片
void loadfile_scanf(char* dirname, char* next, char* kind, IMAGE** pentablev2)
{
	// 文件存储信息结构体
	struct _finddata_t fileinfo;
	// 保存文件句柄
	long fHandle;
	// 文件数记录器
	char dirpath[100];
	strcpy(dirpath, dirname);
	if (access(dirpath, 0) == -1)													// 检查文件夹是否存在,不存在为 -1
	{
		return;
	}
	else
	{
		int i = -1;																	// 记录文件数量
		char kindpath[100];
		strcpy(kindpath, dirpath);
		strcat(kindpath, next);
		strcat(kindpath, kind);
		if ((fHandle = _findfirst(kindpath, &fileinfo)) == -1L) 					// *是通配符,默认在当前文件夹内查找文件,这里查找 .png 文件
		{
			printf("当前目录: %s 下没有所需文件\n", dirname);
			return;
		}
		else
		{
			char path[100];
			do
			{
				i++;
				printf("在%s 下找到文件:%s,文件大小:%d bit\n", dirname, fileinfo.name, fileinfo.size);
				strcpy(path, dirname);
				strcat(path, next);
				strcat(path, fileinfo.name);
				while (pentablev2[i] != NULL)
				{
					i++;
				}
				pentablev2[i] = new IMAGE(30, 30);
				loadimage(pentablev2[i], path, 30, 30);								// 根据名称读取文件
			} while (_findnext(fHandle, &fileinfo) == 0);
		}
		// 关闭文件
		_findclose(fHandle);

		printf("文件数量:%d\n", i + 1);
	}
}
// 使用关键字 inline 声明为内联函数,减少贴图函数频繁调用的开销导致的卡顿。
// 缓冲区纹理映射函数:bkmesh 映射目标,map 映射总网格,pentable:纹理集,bkmeshmapi,bkmeshmapj:映射起始点,tilenum:横,纵映射的数量,pixnum:一个映射块的边长,单位:像素。
inline void freshmesh(IMAGE* bkmesh, int** map, IMAGE* pentable, IMAGE*** pentablev2, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum)
{
	int kind = 0;											// 存储代号第一位:类型
	int number = 0;											// 存储代号第二位:序列号
	int pennumber = -1;										// 暂存每一次循环的映射代号
	IMAGE* pen = NULL;										// 所找到的纹理
	int left = 0;											// 这是每次循环所找到的纹理对应映射地址
	int top = 0;
	SetWorkingImage(bkmesh);								// 设置绘图目标为游戏背景采样区,刷新采样区,刷新寄存区
	setbkcolor(RGB(200, 200, 200));
	cleardevice();
	for (int i = bkmeshmapi; i < bkmeshmapi + tilenum; i++)
	{
		left = 0;
		for (int j = bkmeshmapj; j < bkmeshmapj + tilenum; j++)
		{
			pennumber = map[i][j];							// 读取游戏大地图数组序号
			if (pennumber == -1)
			{
				rectangle(left, top, left + pixnum, top + pixnum);
			}
			else
			{
				kind = pennumber / 10 - 6;						// 剥离第一位
				number = pennumber % 10;						// 剥离最后一位
				if (pennumber < 10)
					pen = &pentable[pennumber];
				else
					pen = pentablev2[kind][number];				// 根据序号查找对应贴图
				putimage(left, top, pen);						// 把贴图画到采样区
			}
			left += pixnum;										// 往右移动,准备下一次绘制位置,此处贴图就会覆盖白色边框。为保证坐标变换和网格对应,算上网格宽度,也在贴图矩形内
		}
		top += pixnum;											// 往下移动,准备下一次绘制位置,此处就会覆盖白色边框,方便定位
	}
	SetWorkingImage();
}

// 在纹理映射函数中产生的图片中截图,但此为演示参数作用,此处并未优化。
inline void freshbk(IMAGE* bk, IMAGE* bkmesh, int gamex, int gamey, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum)
{
	SetWorkingImage(bkmesh);
	getimage(bk, gamex - bkmeshmapj * pixnum, gamey - bkmeshmapi * pixnum, tilenum * pixnum, tilenum * pixnum);
	SetWorkingImage();
}
// 在屏幕显示截图
inline void showbk(IMAGE* bk, int bkdeskx, int bkdesky)
{
	SetWorkingImage();
	putimage(bkdeskx, bkdesky, bk);
}
// 在屏幕上显示缓冲区
inline void showbkmesh(IMAGE* bkmesh, int bkmeshdeskx, int bkmeshdesky)
{
	SetWorkingImage();
	putimage(bkmeshdeskx, bkmeshdesky, bkmesh);
}
// 检查边界
inline void checkboundary(int* bkgameleft, int* bkgametop, int gamelimitright, int gamelimitbuttom, int* bkmeshgameleft, int* bkmeshgametop, int* meshlimitright, int* meshlimitbuttom, int move, int size)
{
	if (*bkgameleft < 0)												// 网格越界检测并调整
		*bkgameleft = 0;
	else if (*bkgameleft > gamelimitright)
		*bkgameleft = gamelimitright;
	if (*bkgametop < 0)
		*bkgametop = 0;
	else if (*bkgametop > gamelimitbuttom)
		*bkgametop = gamelimitbuttom;
	if (*bkgameleft < *bkmeshgameleft)									// 更新游戏采样区坐标,一些简单换算,由于频繁调用函数在这里产生了明显的卡顿影响,所以这里就不再封装成函数
	{
		*bkmeshgameleft -= move;
		*meshlimitright = *bkmeshgameleft + size;
	}
	else if (*bkgameleft > *meshlimitright)
	{
		*meshlimitright += move;
		*bkmeshgameleft = *meshlimitright - size;
	}
	if (*bkgametop < *bkmeshgametop)
	{
		*bkmeshgametop -= move;
		*meshlimitbuttom = *bkmeshgametop + size;
	}
	else if (*bkgametop > *meshlimitbuttom)
	{
		*meshlimitbuttom += move;
		*bkmeshgametop = *meshlimitbuttom - size;
	}
}
// 实时渐变小动画
inline void animation(int characterflag, int bkgameleft, int bkgametop, int bkmeshgameleft, int bkmeshgametop, int bkmeshdeskleft, int bkmeshdesktop)
{
	static int i = 1;
	static int x = 10;
	static int y = 10;
	if (i % 3 == 0)
	{
		x = bkmeshdeskleft + bkgameleft - bkmeshgameleft;
		y = bkmeshdesktop + bkgametop - bkmeshgametop;
		i %= 125;														// i 的上限 * 放大倍数 不超过 255
		switch (characterflag)											// 选取颜色
		{
		case 1:
			setfillcolor(RGB(i * 2, i * 2, 0));
			break;
		case 2:
			setfillcolor(RGB(i * 2, 0, i * 2));
			break;
		case 3:
			setfillcolor(RGB(i * 2, 0, 0));
			break;
		case 4:
			setfillcolor(RGB(0, i * 2, 0));
			break;
		case 5:															// 如果没有按键,则使用默认颜色
			setfillcolor(RGB(0, 0, i * 2));
			break;
		}
		fillrectangle(x, y, x + 30, y + 30);
	}
	i++;
}
相关推荐
程序伍六七8 分钟前
day16
开发语言·c++
小陈phd26 分钟前
Vscode LinuxC++环境配置
linux·c++·vscode
火山口车神丶40 分钟前
某车企ASW面试笔试题
c++·matlab
jiao_mrswang1 小时前
leetcode-18-四数之和
算法·leetcode·职场和发展
qystca1 小时前
洛谷 B3637 最长上升子序列 C语言 记忆化搜索->‘正序‘dp
c语言·开发语言·算法
薯条不要番茄酱1 小时前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
今天吃饺子1 小时前
2024年SCI一区最新改进优化算法——四参数自适应生长优化器,MATLAB代码免费获取...
开发语言·算法·matlab
是阿建吖!1 小时前
【优选算法】二分查找
c++·算法
王燕龙(大卫)1 小时前
leetcode 数组中第k个最大元素
算法·leetcode
不去幼儿园2 小时前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习