devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

easyx devc++ 开发具有导出文件夹DLC的瓦片地图编辑器

作者：weixin_40725706 | 2024-02-14 12:26:50

赞

踩

easyx devc++ 开发具有导出文件夹DLC的瓦片地图编辑器

 1. F1保存为 DLC 输出为当前文件目录下。

2. 瓦片的边框利用绘制到 -1 -1 把边框绘制到外部

3. 利用 +1 实现网格保留

  1. #include <graphics.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <io.h>
  5. // 保存游戏地图贴图数据
  6. void savegamemap(int** map,int gamemapi,int gamemapj,IMAGE* pentable,int pixnum);
  7. // 使用关键字 inline 声明为内联函数，减少贴图函数频繁调用的开销导致的卡顿。
  8. // 缓冲区纹理映射函数：bkmesh 映射目标，map 映射总网格，pentable：纹理集，bkmeshmapi，bkmeshmapj：映射起始点，tilenum:横，纵映射的数量，pixnum:一个映射块的边长，单位：像素。
  9. inline void freshmesh(IMAGE* bkmesh, int** map, IMAGE* pentable, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum)
  10. {
  11. 	int pennumber = 0;										// 暂存每一次循环的映射代号
  12. 	IMAGE pen = NULL;										// 所找到的纹理
  13. 	int left = 0;											// 这是每次循环所找到的纹理对应映射地址
  14. 	int top = 0;
  15. 	SetWorkingImage(bkmesh);								// 设置绘图目标为游戏背景采样区，刷新采样区，刷新寄存区
  16. 	for (int i = bkmeshmapi; i < bkmeshmapi + tilenum; i++)
  17. 	{
  18. 		left = 0;
  19. 		for (int j = bkmeshmapj; j < bkmeshmapj + tilenum; j++)
  20. 		{
  21. 			pennumber = map[i][j];							// 读取游戏大地图数组序号
  22. 			pen = pentable[pennumber];						// 根据序号查找对应贴图
  23. 			putimage(left, top, &pen);						// 把贴图画到采样区
  24. 			left += pixnum+1;									// 往右移动，准备下一次绘制位置，+1 留出白色背景 
  25. 		}
  26. 		top += pixnum+1;										// 往下移动，准备下一次绘制位置，+1 留出白色背景 
  27. 	}
  28. 	SetWorkingImage();
  29. }
  30. // 在纹理映射函数中产生的图片中截图，但此为演示参数作用，此处并未优化。
  31. inline void freshbk(IMAGE* bk, IMAGE* bkmesh, int gamex, int gamey, int bkmeshmapi, int bkmeshmapj, int tilenum, int pixnum)
  32. {
  33. 	SetWorkingImage(bkmesh);
  34. 	getimage(bk, gamex - bkmeshmapj * pixnum, gamey - bkmeshmapi * pixnum, tilenum * pixnum, tilenum * pixnum);
  35. 	SetWorkingImage();
  36. }
  37. // 在屏幕显示截图
  38. inline void showbk(IMAGE* bk, int bkdeskx, int bkdesky)
  39. {
  40. 	SetWorkingImage();
  41. 	putimage(bkdeskx, bkdesky, bk);
  42. }
  43. // 在屏幕上显示缓冲区
  44. inline void showbkmesh(IMAGE* bkmesh, int bkmeshdeskx, int bkmeshdesky)
  45. {
  46. 	SetWorkingImage();
  47. 	putimage(bkmeshdeskx, bkmeshdesky, bkmesh);
  48. }
  49. // 初始化游戏地图
  50. int** initmap(int wide,int high)
  51. {
  52. 	int**map = new int* [high];						// 二维数组动态初始化，先给二级指针挂上一个长度为 10 的指针数组
  53. 	for (int i = 0; i < high ; i++)
  54. 	{
  55. 		map[i] = new int[wide];						// 然后数组里的每个指针都挂上一个长度为 10 的 int 类型数组
  56. 	}
  57. 	for (int i = 0; i <high; i++)
  58. 	{
  59. 		for (int j = 0; j < wide; j++)
  60. 		{
  61. 			map[i][j] = 1;						// 初始化游戏大地图 map 的参数，参数范围 3
  62. 		}
  63. 	}
  64. 	return map;
  65. }
  66. int main()
  67. {
  68. 	initgraph(1640, 980, 1);
  69. 	setbkcolor(GREEN);
  70. 	cleardevice();
  71. 	IMAGE* bk;									// 背景图片寄存区
  72. 	bk = new IMAGE(270, 270);
  73. 	IMAGE* bkmesh;								// 背景图片采样区
  74. 	bkmesh = new IMAGE(270 * 3, 270 * 3);
  75. 	int** map;									// 游戏大地图数组，记录着整个游戏背景的贴图信息，而在运行过程中，选取部分区域的数字，对照序号与贴图，实现游戏背景绘制。其余没有选中的区域就是压缩的空间。
  76. 	int pixnum;									// 一个正方形瓦片的边长。单位：像素
  77. 	int bkgameleft;								// 背景图片寄存区左上角坐标，是在游戏里的像素坐标。（0，0）可以理解为游戏大地图的左上角顶点。
  78. 	int bkgametop;
  79. 	int bkmeshgameleft;							// 背景图片采样区左上角坐标，是在游戏里的像素坐标。
  80. 	int bkmeshgametop;
  81. 	int bkmeshmapi;								// 背景图片采样区左上角所对应的 map 数组序号。从 map[0][0]开始，按照 map[i][j]，其中 bkmeshmapi=bkmeshtop/pixnum
  82. 	int bkmeshmapj;
  83. 	int bkdeskleft;								// 规定在屏幕上显示游戏背景寄存区，此处记录其左上角在屏幕上的像素坐标
  84. 	int bkdesktop;
  85. 	int bkmeshdeskleft;							// 规定在屏幕上显示游戏背景采样区，此处记录其左上角在屏幕上的像素坐标
  86. 	int bkmeshdesktop;
  87. 	pixnum = 30;									// 进行初始化，规定各位置具体数字
  88. 	bkdeskleft = 200;								// 游戏背景左上角将会在屏幕的（200，200) 处
  89. 	bkdesktop = 200;
  90. 	bkgameleft = 0;
  91. 	bkgametop = 0;
  92. 	bkmeshdeskleft = 700;							// 游戏背景缓冲区左上角将会在屏幕的（700，0）处
  93. 	bkmeshdesktop = 0;
  94. 	bkmeshgameleft = 0;
  95. 	bkmeshgametop = 0;
  96. 	bkmeshmapi = bkmeshgametop / pixnum;
  97. 	bkmeshmapj = bkmeshgameleft / pixnum;
  98. 	map=initmap(1000,1000);							// 初始化一个有1000*1000个贴图的地图
  99. 	int pentableleft;								// 忘了初始化调色盘了，这里设置调色盘左上角在屏幕的坐标
  100. 	int pentabletop;
  101. 	IMAGE* pentable;								// 调色板其实就是贴图数组
  102. 	pentableleft = 0;								// 调色盘左上角将会在屏幕的（0，0）处
  103. 	pentabletop = 0;
  104. 	pentable = new IMAGE[10];
  105. 	for (int i = 0; i < 10; i++)
  106. 	{
  107. 		pentable[i] = IMAGE(30, 30);
  108. 		SetWorkingImage(&pentable[i]);					// 给调色板绘制颜色
  109. 		setfillcolor(RGB(i * 20, i * 20, i * 20));		// 这里初始化调色盘的颜色
  110. 		fillrectangle(-1, -1, pixnum, pixnum);			// 在调色板上绘制颜色（纹理） 要从 -1，-1 开始绘制，把边框画到外部，不保留边框。 
  111. 	}
  112. 	int left;												// 初始化绘制采样区所需的坐标，相对于采样区，（0，0）就是采样区左上角顶点坐标
  113. 	int top;
  114. 	left = 0;
  115. 	top = 0;
  116. 	//	往缓冲区刷入贴图
  117. 	SetWorkingImage(bkmesh);								// 设置绘图目标为游戏背景采样区,刷新采样区，刷新寄存区
  118. 	setbkcolor(RGB(200,200,200));
  119. 	cleardevice(); 
  120. 	for (int i = bkmeshmapi; i < bkmeshmapi + 30; i++)
  121. 	{
  122. 		left = 0;
  123. 		for (int j = bkmeshmapj; j < bkmeshmapj + 30; j++)
  124. 		{
  125. 			int pennumber = map[i][j];						// 读取游戏大地图数组序号
  126. 			IMAGE pen = pentable[pennumber];				// 根据序号查找对应贴图
  127. 			putimage(left, top, &pen);						// 把贴图画到采样区
  128. 			left += pixnum+1;								// 往右移动，准备下一次绘制位置, 此处 +1 是增加白色边框，方便定位 
  129. 		}
  130. 		top += pixnum+1;									// 往下移动，准备下一次绘制位置，此处 +1 是增加白色边框，方便定位 
  131. 	}
  132. 	getimage(bk, bkgameleft, bkgametop, 270, 270);			// 从刚刚绘制好的采样区取样，刷新游戏背景寄存区。
  133. 	//	开始往屏幕上绘图
  134. 	SetWorkingImage();															// 设置电脑屏幕为绘制对象
  135. 	for (int j = 0; j < 10; j++)
  136. 	{
  137. 		putimage(pentableleft + 10, pentabletop + j * 30, &pentable[j]); 		// 绘制绘图板
  138. 	}
  139. 	putimage(bkdeskleft, bkdesktop, bk);										// 绘制游戏背景
  140. 	putimage(bkmeshdeskleft, bkmeshdesktop, bkmesh); 							// 显示游戏背景缓冲区
  141. 	// 此时绘制完成，以上 刷贴图，采样，粘贴就是实现 RPG 游戏大地图的压缩
  142. 	//	开始检测鼠标键盘功能
  143. 	int drawflag;															// 设置长按 flag
  144. 	int drawoldmx;															// 记录上一次绘制时的鼠标坐标，用于检测是否重复点击相同像素，来减少重复绘制
  145. 	int drawoldmy;
  146. 	int drawx;																// 画笔在游戏里的位置，单位像素
  147. 	int drawy;
  148. 	int olddrawi;															// 记录上一次绘制的瓦片，判断是否需要重新绘制
  149. 	int olddrawj;
  150. 	int drawsmallflag;														// 在 drawflag=1 时，检测是否刷新
  151. 	drawsmallflag=0;
  152. 	olddrawi=0;
  153. 	olddrawj=0;
  154. 	drawx = 0;
  155. 	drawy = 0;
  156. 	drawflag = 0;
  157. 	drawoldmx = 0;
  158. 	drawoldmy = 0;
  159. 	int pentake;															// 设置不绘制时贴图代号为 -1
  160. 	pentake = 0;															// 默认黑色笔刷
  161. 	int draftoldmx;															// 记录刚刚拖拽时的鼠标的位置，用于坐标变换计算位移
  162. 	int draftoldmy;
  163. 	int draftoldgamex;														// 记录刚刚拖拽时的游戏地图位置，用于坐标变换计算新的游戏坐标
  164. 	int draftoldgamey;
  165. 	int draftflag;															// 设置拖拽 flag
  166. 	draftoldmx = 0;
  167. 	draftoldmy = 0;
  168. 	draftoldgamex = 0;
  169. 	draftoldgamey = 0;
  170. 	draftflag = 0;
  171. 	int moveflag;															// 是否键盘控制移动
  172. 	int flag_x;																// 记录位移
  173. 	int flag_y;
  174. 	int speed;																// 键盘控制视口的移动速度
  175. 	speed=5;
  176. 	flag_x=0;
  177. 	flag_y=0;
  178. 	moveflag=0;
  179. 	int mousex;																// 记录鼠标位置
  180. 	int mousey;
  181. 	mousex=0;
  182. 	mousey=0;
  183. 	int oldbkmeshgamex;														// 判断拖拽时是否需要刷新 bkmesh 网格
  184. 	int oldbkmeshgamey;
  185. 	ExMessage m;
  186. 	while (1)
  187. 	{
  188. 		while (peekmessage(&m, EX_KEY | EX_MOUSE))		// 一次性处理完鼠标消息，参考自 https://codebus.cn/zhaoh/handle-mouse-messages-correctly
  189. 		{
  190. 			switch (m.message)
  191. 			{
  192. 				case WM_LBUTTONDOWN:																				// 鼠标左键按下，有两种情况，一是选择贴图，另外就是绘制贴图
  193. 					if (drawflag==0&&m.x > bkdeskleft && m.y > bkdesktop && m.x < bkdeskleft + 300 && m.y < bkdesktop + 300)		// 如果之前不是长按状态	且按下左键时，鼠标在游戏背景区域内
  194. 					{
  195. 						drawflag = 1;																				// 才记录为正在绘制的状态
  196. 						mousex=m.x;
  197. 						mousey=m.y;
  198. 					}
  199. 					else if (drawflag==0&&draftflag==0&&m.x > 0 && m.y > 0 && m.x < 30 && m.y < 300)
  200. 						pentake = m.y / 30; 																		// 选择贴图对应的代号
  201. 					break;
  202. 				case WM_LBUTTONUP:
  203. 					drawflag = 0;
  204. 					drawsmallflag=0;
  205. 					olddrawi=0;
  206. 					olddrawj=0;
  207. 					break;
  208. 				case WM_RBUTTONDOWN:																				// 鼠标右键拖动
  209. 					if (draftflag==0&&m.x > bkdeskleft && m.y > bkdesktop && m.x < bkdeskleft + 270 && m.y < bkdesktop + 270)
  210. 					{
  211. 						draftflag = 1;
  212. 						draftoldmx = m.x;																			// 记录鼠标坐标
  213. 						draftoldmy = m.y;
  214. 						mousex=m.x;
  215. 						mousey=m.y;
  216. 						draftoldgamex = bkgameleft;																	// 记录游戏背景寄存区左上角坐标
  217. 						draftoldgamey = bkgametop;
  218. 					}
  219. 					break;
  220. 				case WM_RBUTTONUP:
  221. 					draftflag = 0;
  222. 					bkgameleft = draftoldgamex - (m.x - draftoldmx);												// bkgameleft - draftoldgamex =- (m.x - draftoldmx)
  223. 					bkgametop = draftoldgamey - (m.y - draftoldmy);													// bkgametop - draftoldgamey =- (m.y - draftoldmy)
  224. 					break;
  225. 				case WM_KEYDOWN:
  226. 					switch (m.vkcode)					// 键盘移动控制
  227. 					{
  228. 						case 0x41:						// A
  229. 							flag_x-=speed;
  230. 							moveflag=1;
  231. 							break;
  232. 						case 0x57:						// W
  233. 							flag_y-=speed;
  234. 							break;
  235. 						case 0x44:						// D
  236. 							flag_x+=speed;
  237. 							break;
  238. 						case 0x53:						// S
  239. 							flag_y+=speed;
  240. 							break;
  241. 						case VK_F1:
  242. 							savegamemap(map,300,300,pentable,pixnum);
  243. 							break;
  244. 					}
  245. 					break;
  246. 				case WM_KEYUP:
  247. 					switch(m.vkcode)
  248. 					{
  249. 						case 0x41:						// A
  250. 							flag_x=0;
  251. 							break;
  252. 						case 0x57:						// W
  253. 							flag_y=0;
  254. 							break;
  255. 						case 0x44:						// D
  256. 							flag_x=0;
  257. 							break;
  258. 						case 0x53:						// S
  259. 							flag_y=0;
  260. 							break;
  261. 					}
  262. 					break;
  263. 				case WM_MOUSEMOVE:
  264. 					if(mousex!=m.x||mousey!=m.y)
  265. 					{
  266. 						mousex=m.x;
  267. 						mousey=m.y;
  268. 					}
  269. 					break;
  270. 			}
  271. 		}
  272. //		开始根据指令运行坐标变化
  273. 		if (draftflag == 1)
  274. 		{
  275. 			bkgameleft = draftoldgamex - (mousex - draftoldmx);											// bkgameleft-draftoldgamex=-(mousex-draftoldmx)
  276. 			bkgametop = draftoldgamey - (mousey - draftoldmy);											// bkgametop-draftoldgamey=-(mousey - draftoldmy)
  277. 		}
  278. 		else if (drawflag == 1&&flag_x==0&&flag_y==0 &&(drawoldmx!=mousex||drawoldmy!=mousey)&& mousex > bkdeskleft && mousey > bkdesktop && mousex < bkdeskleft + 300 && mousey < bkdesktop + 300)
  279. 		{
  280. 			// 注意不要越界，否则 gamex 为负数，导致数组越界闪退。
  281. 			// 通过实现坐标变换与赋值达到修改游戏大地图（数组）
  282. 			moveflag=0;
  283. 			drawoldmx = mousex;
  284. 			drawoldmy = mousey;
  285. 			drawx = bkgameleft + (mousex - bkdeskleft);										// drawx-bkgameleft=mousex-bkdeskleft	横坐标方向移动距离相同
  286. 			drawy = bkgametop + (mousey - bkdesktop);										// drawy-bkgametop=mousey-bkdesktop	纵坐标方向移动距离相同
  287. 			if(olddrawi!=drawy/pixnum||olddrawj!=drawx/pixnum)
  288. 			{
  289. 				drawsmallflag=1;
  290. 				olddrawi=drawy / pixnum;
  291. 				olddrawj=drawx / pixnum;
  292. 				map[olddrawi][olddrawj] = pentake;											// 注意 map[y][x]，而不是 map[x][y]，因为判断第几行，是通过 y 来控制上下移动的，判断第几列，是通过 x 左右移动的。
  293. 			}
  294. 			else
  295. 			{
  296. 				drawsmallflag=0;															// 检测到是上一次绘制的瓦片，则不再刷新贴图与缓冲区。
  297. 			}
  298. 		}	//	对绘制进行分类计算数据，剥离特殊情况的重复绘制,仅仅是 flag_x,或者flag_y不为零时取消重复绘制判断。
  299. 		else if(drawflag == 1 && mousex > bkdeskleft && mousey > bkdesktop && mousex < bkdeskleft + 300 && mousey < bkdesktop + 300)
  300. 		{
  301. 			moveflag=1;
  302. 			while(flag_x<-10)																// 限制在合适速度范围
  303. 				flag_x+=10;
  304. 			while(flag_x>10)
  305. 				flag_x-=10;
  306. 			while(flag_y<-10)
  307. 				flag_y+=10;
  308. 			while(flag_y>10)
  309. 				flag_y-=10;
  310. 			bkgameleft+=flag_x;																// 更新游戏背景寄存区左上角坐标
  311. 			bkgametop+=flag_y;
  312. 			drawx = bkgameleft + (mousex - bkdeskleft);										// drawx-bkgameleft=m.x-bkdeskleft	横坐标方向移动距离相同
  313. 			drawy = bkgametop + (mousey - bkdesktop);										// drawy-bkgametop=m.y-bkdesktop	纵坐标方向移动距离相同
  314. 			if(olddrawi!=drawy/pixnum||olddrawj!=drawx/pixnum)
  315. 			{
  316. 				drawsmallflag=1;
  317. 				olddrawi=drawy / pixnum;
  318. 				olddrawj=drawx / pixnum;
  319. 				map[olddrawi][olddrawj] = pentake;											// 注意 map[y][x]，而不是 map[x][y]，因为判断第几行，是通过 y 来控制上下移动的，判断第几列，是通过 x 左右移动的。
  320. 			}
  321. 			else
  322. 			{
  323. 				drawsmallflag=0;															// 检测到是上一次绘制的瓦片，则不再刷新贴图与缓冲区。
  324. 			}
  325. 		}
  326. 		else if(drawflag==0&&flag_x!=0||flag_y!=0)
  327. 		{
  328. 			moveflag=1;
  329. 			while(flag_x<-10)																// 限制在合适速度范围
  330. 				flag_x+=10;
  331. 			while(flag_x>10)
  332. 				flag_x-=10;
  333. 			while(flag_y<-10)
  334. 				flag_y+=10;
  335. 			while(flag_y>10)
  336. 				flag_y-=10;
  337. 			bkgameleft+=flag_x;
  338. 			bkgametop+=flag_y;
  339. 		}
  340. 		else
  341. 		{
  342. 			// 既不绘制也不移动也不拖拽
  343. 		}
  344. 		// 根据计算出的坐标数据进行绘制，分多种情况分别绘制，减少函数重复调用与无效调用
  345. 		if(drawsmallflag==1&&moveflag==0)
  346. 		{
  347. 			freshmesh(bkmesh, map, pentable, bkmeshmapi, bkmeshmapj, 27, 30);			// 刷新，重新映射，其实就是开头初始化的代码，这里是给了一个封装示例，但未进行性能优化
  348. 			freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, 30);
  349. 			showbk(bk, bkdeskleft, bkdesktop);
  350. 			showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
  351. 		}
  352. 		else if(moveflag==1&&drawsmallflag==1)
  353. 		{
  354. 			if(bkgameleft<0)															// 网格越界检测并调整
  355. 				bkgameleft=0;
  356. 			if(bkgametop<0)
  357. 				bkgametop=0;
  358. 			if(bkgameleft>30*300)
  359. 				bkgameleft=30*300;
  360. 			if(bkgametop>30*300)
  361. 				bkgametop=30*300;
  362. 			while (bkgameleft < bkmeshgameleft)											// 更新游戏采样区坐标，一些简单换算
  363. 				bkmeshgameleft -=270;
  364. 			while (bkgametop <bkmeshgametop )
  365. 				bkmeshgametop -= 270;
  366. 			while(bkgameleft>bkmeshgameleft+270+270)
  367. 				bkmeshgameleft += 270;
  368. 			while(bkgametop>bkmeshgametop+270+270)
  369. 				bkmeshgametop += 270;
  370. 			bkmeshmapi = bkmeshgametop / pixnum;
  371. 			bkmeshmapj = bkmeshgameleft / pixnum;
  372. 			freshmesh(bkmesh, map, pentable, bkmeshmapi, bkmeshmapj, 27, 30);
  373. 			freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, 30);
  374. 			showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
  375. 			showbk(bk, bkdeskleft, bkdesktop);
  376. 		}
  377. 		else if(moveflag==1)															// 分类渲染, drawflag==0 时，再选择性刷新缓冲区
  378. 		{
  379. 			if(bkgameleft<0)															// 网格越界检测并调整
  380. 				bkgameleft=0;
  381. 			if(bkgametop<0)
  382. 				bkgametop=0;
  383. 			if(bkgameleft>30*300)
  384. 				bkgameleft=30*300;
  385. 			if(bkgametop>30*300)
  386. 				bkgametop=30*300;
  387. 			while (bkgameleft < bkmeshgameleft)											// 更新游戏采样区坐标，一些简单换算，由于频繁调用函数在这里产生了明显的卡顿影响，所以这里就不再封装成函数
  388. 				bkmeshgameleft -=270;
  389. 			while (bkgametop <bkmeshgametop )
  390. 				bkmeshgametop -= 270;
  391. 			while(bkgameleft>bkmeshgameleft+270+270)
  392. 				bkmeshgameleft += 270;
  393. 			while(bkgametop>bkmeshgametop+270+270)
  394. 				bkmeshgametop += 270;
  395. 			bkmeshmapi = bkmeshgametop / pixnum;
  396. 			bkmeshmapj = bkmeshgameleft / pixnum;
  397. 			if(oldbkmeshgamex!=bkmeshgameleft||oldbkmeshgamey!=bkmeshgametop)			// 判断是否更新采样区
  398. 			{
  399. 				freshmesh(bkmesh, map, pentable, bkmeshmapi, bkmeshmapj, 27, 30);
  400. 				oldbkmeshgamex=bkmeshgameleft;
  401. 				oldbkmeshgamey=bkmeshgametop;
  402. 				showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
  403. 			}
  404. 			freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, 30);
  405. 			showbk(bk, bkdeskleft, bkdesktop);
  406. 		}
  407. 		else if(draftflag)																// 分类渲染-只拖拽
  408. 		{
  409. 			if(bkgameleft<0)															// 网格越界检测并调整
  410. 				bkgameleft=0;
  411. 			if(bkgametop<0)
  412. 				bkgametop=0;
  413. 			if(bkgameleft>30*300)
  414. 				bkgameleft=30*300;
  415. 			if(bkgametop>30*300)
  416. 				bkgametop=30*300;
  417. 			while (bkgameleft < bkmeshgameleft)											// 更新游戏采样区坐标，一些简单换算
  418. 				bkmeshgameleft -=270;
  419. 			while (bkgametop <bkmeshgametop )
  420. 				bkmeshgametop -= 270;
  421. 			while(bkgameleft>bkmeshgameleft+270+270)
  422. 				bkmeshgameleft += 270;
  423. 			while(bkgametop>bkmeshgametop+270+270)
  424. 				bkmeshgametop += 270;
  425. 			bkmeshmapi = bkmeshgametop / pixnum;
  426. 			bkmeshmapj = bkmeshgameleft / pixnum;
  427. 			if(oldbkmeshgamex!=bkmeshgameleft||oldbkmeshgamey!=bkmeshgametop)			// 判断是否更新采样区
  428. 			{
  429. 				freshmesh(bkmesh, map, pentable, bkmeshmapi, bkmeshmapj, 27, 30);
  430. 				oldbkmeshgamex=bkmeshgameleft;
  431. 				oldbkmeshgamey=bkmeshgametop;
  432. 				showbkmesh(bkmesh, bkmeshdeskleft, bkmeshdesktop);
  433. 			}
  434. 			freshbk(bk, bkmesh, bkgameleft, bkgametop, bkmeshmapi, bkmeshmapj, 9, 30);
  435. 			showbk(bk, bkdeskleft, bkdesktop);
  436. 		}
  437. 		Sleep(20);																		// 休眠 20 毫秒，减少 CPU 占用
  438. 	}
  439. 	return 0;
  440. }
  441. // 边绘制边移动：最大：边界 2.30GHz 3%占用，内部 2.25Ghz。仅绘制:1.8GHz, 拖拽:0.99GHz，旧瓦片绘制检测，又减少重复绘制，显著平稳，峰值降低
  442. void savegamemap(int** map,int gamemapi,int gamemapj,IMAGE* pentable,int pixnum)
  443. {
  444. 	FILE* fp;
  445. 	int i=0;
  446. 	int j=0;
  447. 	char dirpath[400]={'\0'};
  448. 	char filepath[400]={'\0'};
  449. 	for(i=0;i<100;i++){
  450. 		sprintf(dirpath,"DLC%d",i);
  451. 		if(access(dirpath,0)==-1){										// 检查 DLC 是否存在，不存在为 -1 
  452. 			break;
  453. 		}
  454. 	}
  455. 	mkdir(dirpath);														// 创建文件夹 
  456. 	char filename[400]="gamemap.txt";
  457. 	const char* next="./";
  458. 	strcat(filepath,dirpath);
  459. 	strcat(filepath,next);
  460. 	strcat(filepath,filename);
  461. 	fp=fopen(filepath,"w+");											// 创建 .txt 文件 
  462. 	fprintf(fp,"注意此导出的游戏文件为按键 F1 后自动生成 修改汉语字符或者英文字符 或导致该 .txt 文件不可读取\n");
  463. 	fprintf(fp,"warning this saved gamefile is automatically create after F1 pressed change Chinesse character or English character lead to read failed");
  464. 	fprintf(fp,"pixnum %d\n",pixnum);									// 正方形瓦片贴图边长信息：单位：像素 
  465. 	fprintf(fp,"imagenum %d\n",10);										// 瓦片个数 
  466. 	char c[400]={'\0'};
  467. 	for(i=0;i<10;i++){
  468. 		sprintf(c,"tile_%d.png",i);
  469. 		fprintf(fp,"%s\n",c);
  470. 	} 
  471. 	fprintf(fp,"gamemapi %d gamemapj %d\n",gamemapi,gamemapj);
  472. 	for(i=0; i<gamemapi; i++)
  473. 	{
  474. 		fprintf(fp,"%d",map[i][j]);
  475. 		for(j=0; j<gamemapj; j++)
  476. 		{
  477. 			fprintf(fp," %d",map[i][j]);
  478. 		}
  479. 		fprintf(fp,"\n");
  480. 	}
  481. 	fclose(fp);
  482. 	char imagename[400]= {'\0'};
  483. 	char imagepath[400]={'\0'}; 
  484. 	for(i=0; i<10; i++)
  485. 	{
  486. 		sprintf(imagename,"tile_%d.png",i);							// 数字转字符串
  487. 		strcpy(imagepath,dirpath);									// 函数直接从头开始粘贴，自动清除开头的字符 
  488. 		strcat(imagepath,next);
  489. 		strcat(imagepath,imagename);
  490. 		saveimage(imagepath,&pentable[i]);							// 批量导出贴图
  491. 	}
  492. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/80348
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号