基于迷宫地牢生成与自动寻路代码

已于 2024-05-06 12:45:09 修改
阅读量184 收藏 2
点赞数 9
文章标签： android
于 2024-05-06 12:40:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1309602336/article/details/138490712
版权

 

首先是需要一个生成 地牢文件 maze.txt 生成代码

代码来自

一种 Roguelike 地牢生成算法 | indienova 独立游戏

C++ Example of Dungeon-Building Algorithm - RogueBasin

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <ctime>

//https://www.roguebasin.com/index.php?title=C%2B%2B_Example_of_Dungeon-Building_Algorithm
//https://indienova.com/indie-game-development/roguelike-dungeon-building-algorithm/
//https://indienova.com/indie-game-development/rooms-and-mazes-a-procedural-dungeon-generator/
class Dungeon
{
	int xmax;
	int ymax;
	
	int xsize;
	int ysize;
	
	int objects;
	
	int chanceRoom;
	int chanceCorridor;
	
	int* dungeon_map;
	
	long oldseed;
	
	enum
	{
		tileUnused = 0,
		tileDirtWall=1,
		tileDirtFloor=2,
		tileStoneWall=3,
		tileCorridor=4,
		tileDoor=5,
		tileUpStairs=6,
		tileDownStairs=7,
		tileChest=8
	};
	
	std::string msgXSize;
	std::string msgYSize;
	std::string msgMaxObjects;
	std::string msgNumObjects;
	std::string msgHelp;
	std::string msgDetailedHelp;
	
	void setCell(int x, int y, int celltype)
	{
		dungeon_map[x + xsize * y] = celltype;
	}
	int getCell(int x, int y)
	{
		return dungeon_map[x + xsize * y];
	}
	
	int getRand(int min, int max)
	{
		time_t seed;
		seed = time(NULL) + oldseed;
		oldseed = seed;
		
		srand(seed);
		
		int n = max - min + 1;
		int i = rand() % n;
		
		if(i < 0)
			i = -i;
		
		return min + i;
	}
	
	bool makeCorridor(int x, int y, int lenght, int direction)
	{
		int len = getRand(2, lenght);
		int floor = tileCorridor;
		int dir = 0;
		if(direction > 0 && direction < 4) dir = direction;
		
		int xtemp = 0;
		int ytemp = 0;
		
		switch(dir)
		{
		case 0:
			{
				if(x < 0 || x > xsize) return false;
				else xtemp = x;
				
				for(ytemp = y; ytemp > (y-len); ytemp--)
				{
					if(ytemp < 0 || ytemp > ysize) return false;
					if(getCell(xtemp, ytemp) != tileUnused) return false;
				}
				
				for(ytemp = y; ytemp > (y - len); ytemp--)
				{
					setCell(xtemp, ytemp, floor);
				}
				break;
				
			}
		case 1:
			{
				if(y < 0 || y > ysize) return false;
				else ytemp = y;
				
				for(xtemp = x; xtemp < (x + len); xtemp++)
				{
					if(xtemp < 0 || xtemp > xsize) return false;
					if(getCell(xtemp, ytemp) != tileUnused) return false;
				}
				
				for(xtemp = x; xtemp < (x + len); xtemp++)
				{
					setCell(xtemp, ytemp, floor);
				}
				break;
			}
		case 2:
			{
				if(x < 0 || x > xsize) return false;
				else xtemp = x;
				
				for(ytemp = y; ytemp < (y + len); ytemp++)
				{
					if(ytemp < 0 || ytemp > ysize) return false;
					if(getCell(xtemp, ytemp) != tileUnused) return false;
				}
				for (ytemp = y; ytemp < (y+len); ytemp++){
					setCell(xtemp, ytemp, floor);
				}
				break;
			}
		case 3:
			{
				if (ytemp < 0 || ytemp > ysize) return false;
				else ytemp = y;
				
				for (xtemp = x; xtemp > (x-len); xtemp--){
					if (xtemp < 0 || xtemp > xsize) return false;
					if (getCell(xtemp, ytemp) != tileUnused) return false;
				}
				
				for (xtemp = x; xtemp > (x-len); xtemp--){
					setCell(xtemp, ytemp, floor);
				}
				break;
			}
		}
		//woot, we're still here! let's tell the other guys we're done!!
		return true;
	}
	bool makeRoom(int x, int y, int xlength, int ylength, int direction){
		//define the dimensions of the room, it should be at least 4x4 tiles (2x2 for walking on, the rest is walls)
		int xlen = getRand(4, xlength);
		int ylen = getRand(4, ylength);
		//the tile type it's going to be filled with
		int floor = tileDirtFloor; //jordgolv..
		int wall = tileDirtWall; //jordv????gg
		//choose the way it's pointing at
		int dir = 0;
		if (direction > 0 && direction < 4) dir = direction;
		
		switch(dir){
		case 0:
			//north
			//Check if there's enough space left for it
			for (int ytemp = y; ytemp > (y-ylen); ytemp--){
				if (ytemp < 0 || ytemp > ysize) return false;
				for (int xtemp = (x-xlen/2); xtemp < (x+(xlen+1)/2); xtemp++){
					if (xtemp < 0 || xtemp > xsize) return false;
					if (getCell(xtemp, ytemp) != tileUnused) return false; //no space left...
				}
			}
			
			//we're still here, build
			for (int ytemp = y; ytemp > (y-ylen); ytemp--){
				for (int xtemp = (x-xlen/2); xtemp < (x+(xlen+1)/2); xtemp++){
					//start with the walls
					if (xtemp == (x-xlen/2)) setCell(xtemp, ytemp, wall);
					else if (xtemp == (x+(xlen-1)/2)) setCell(xtemp, ytemp, wall);
					else if (ytemp == y) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y-ylen+1)) setCell(xtemp, ytemp, wall);
					//and then fill with the floor
					else setCell(xtemp, ytemp, floor);
				}
			}
			break;
		case 1:
			//east
			for (int ytemp = (y-ylen/2); ytemp < (y+(ylen+1)/2); ytemp++){
				if (ytemp < 0 || ytemp > ysize) return false;
				for (int xtemp = x; xtemp < (x+xlen); xtemp++){
					if (xtemp < 0 || xtemp > xsize) return false;
					if (getCell(xtemp, ytemp) != tileUnused) return false;
				}
			}
			
			for (int ytemp = (y-ylen/2); ytemp < (y+(ylen+1)/2); ytemp++){
				for (int xtemp = x; xtemp < (x+xlen); xtemp++){
					
					if (xtemp == x) setCell(xtemp, ytemp, wall);
					else if (xtemp == (x+xlen-1)) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y-ylen/2)) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y+(ylen-1)/2)) setCell(xtemp, ytemp, wall);
					
					else setCell(xtemp, ytemp, floor);
				}
			}
			break;
		case 2:
			//south
			for (int ytemp = y; ytemp < (y+ylen); ytemp++){
				if (ytemp < 0 || ytemp > ysize) return false;
				for (int xtemp = (x-xlen/2); xtemp < (x+(xlen+1)/2); xtemp++){
					if (xtemp < 0 || xtemp > xsize) return false;
					if (getCell(xtemp, ytemp) != tileUnused) return false;
				}
			}
			
			for (int ytemp = y; ytemp < (y+ylen); ytemp++){
				for (int xtemp = (x-xlen/2); xtemp < (x+(xlen+1)/2); xtemp++){
					
					if (xtemp == (x-xlen/2)) setCell(xtemp, ytemp, wall);
					else if (xtemp == (x+(xlen-1)/2)) setCell(xtemp, ytemp, wall);
					else if (ytemp == y) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y+ylen-1)) setCell(xtemp, ytemp, wall);
					
					else setCell(xtemp, ytemp, floor);
				}
			}
			break;
		case 3:
			//west
			for (int ytemp = (y-ylen/2); ytemp < (y+(ylen+1)/2); ytemp++){
				if (ytemp < 0 || ytemp > ysize) return false;
				for (int xtemp = x; xtemp > (x-xlen); xtemp--){
					if (xtemp < 0 || xtemp > xsize) return false;
					if (getCell(xtemp, ytemp) != tileUnused) return false;
				}
			}
			
			for (int ytemp = (y-ylen/2); ytemp < (y+(ylen+1)/2); ytemp++){
				for (int xtemp = x; xtemp > (x-xlen); xtemp--){
					
					if (xtemp == x) setCell(xtemp, ytemp, wall);
					else if (xtemp == (x-xlen+1)) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y-ylen/2)) setCell(xtemp, ytemp, wall);
					else if (ytemp == (y+(ylen-1)/2)) setCell(xtemp, ytemp, wall);
					
					else setCell(xtemp, ytemp, floor);
				}
			}
			break;
		}
		
		//yay, all done
		return true;
	}
	void showDungeon(){
		for (int y = 0; y < ysize; y++){
			for (int x = 0; x < xsize; x++){
				//System.out.print(getCell(x, y));
				switch(getCell(x, y)){
				case tileUnused:
					printf(" ");
					break;
				case tileDirtWall:
					printf("#");
					break;
				case tileDirtFloor:
					printf(".");
					break;
				case tileStoneWall:
					printf("X");
					break;
				case tileCorridor:
					printf(".");
					break;
				case tileDoor:
					printf("+");
					break;
				case tileUpStairs:
					printf("<");
					break;
				case tileDownStairs:
					printf(">");
					break;
				case tileChest:
					printf("*");
					break;
				};
			}
			if (xsize <= xmax) printf("\n");
		}
	}
	bool createDungeon(int inx, int iny, int inobj){
		if (inobj < 1) objects = 10;
		else objects = inobj;
		
		//justera kartans storlek, om den ????r st????rre eller mindre ????n "gr????nserna"
		//adjust the size of the map, if it's smaller or bigger than the limits
		if (inx < 3) xsize = 3;
		else if (inx > xmax) xsize = xmax;
		else xsize = inx;
		
		if (iny < 3) ysize = 3;
		else if (iny > ymax) ysize = ymax;
		else ysize = iny;
		
		//printf("%s %d\n", msgXSize.c_str(), xsize);
		//printf("%s %d\n", msgYSize.c_str(),  + ysize);
		//printf("%s %d\n", msgMaxObjects.c_str(), objects);
		
		//redefine the map var, so it's adjusted to our new map size
		dungeon_map = new int[xsize * ysize];
		
		//start with making the "standard stuff" on the map
		for (int y = 0; y < ysize; y++){
			for (int x = 0; x < xsize; x++){
				//ie, making the borders of unwalkable walls
				if (y == 0) setCell(x, y, tileStoneWall);
				else if (y == ysize-1) setCell(x, y, tileStoneWall);
				else if (x == 0) setCell(x, y, tileStoneWall);
				else if (x == xsize-1) setCell(x, y, tileStoneWall);
				
				//and fill the rest with dirt
				else setCell(x, y, tileUnused);
			}
		}
		
		/*******************************************************************************
		  And now the code of the random-map-generation-algorithm begins!
		 *******************************************************************************/
		
		//start with making a room in the middle, which we can start building upon
		makeRoom(xsize/2, ysize/2, 8, 6, getRand(0,3)); //getrand saken f????r att slumpa fram riktning p?? rummet
		
		//keep count of the number of "objects" we've made
		int currentFeatures = 1; //+1 for the first room we just made
		
		//then we sart the main loop
		for (int countingTries = 0; countingTries < 1000; countingTries++){
			//check if we've reached our quota
			if (currentFeatures == objects){
				break;
			}
			
			//start with a random wall
			int newx = 0;
			int xmod = 0;
			int newy = 0;
			int ymod = 0;
			int validTile = -1;
			//1000 chances to find a suitable object (room or corridor)..
			//(yea, i know it's kinda ugly with a for-loop... -_-')
			for (int testing = 0; testing < 1000; testing++){
				newx = getRand(1, xsize-1);
				newy = getRand(1, ysize-1);
				validTile = -1;
				//System.out.println("tempx: " + newx + "\ttempy: " + newy);
				if (getCell(newx, newy) == tileDirtWall || getCell(newx, newy) == tileCorridor){
					//check if we can reach the place
					if (getCell(newx, newy+1) == tileDirtFloor || getCell(newx, newy+1) == tileCorridor){
						validTile = 0; //
						xmod = 0;
						ymod = -1;
					}
					else if (getCell(newx-1, newy) == tileDirtFloor || getCell(newx-1, newy) == tileCorridor){
						validTile = 1; //
						xmod = +1;
						ymod = 0;
					}
					else if (getCell(newx, newy-1) == tileDirtFloor || getCell(newx, newy-1) == tileCorridor){
						validTile = 2; //
						xmod = 0;
						ymod = +1;
					}
					else if (getCell(newx+1, newy) == tileDirtFloor || getCell(newx+1, newy) == tileCorridor){
						validTile = 3; //
						xmod = -1;
						ymod = 0;
					}
					
					//check that we haven't got another door nearby, so we won't get alot of openings besides
					//each other
					if (validTile > -1){
						if (getCell(newx, newy+1) == tileDoor) //north
							validTile = -1;
						else if (getCell(newx-1, newy) == tileDoor)//east
							validTile = -1;
						else if (getCell(newx, newy-1) == tileDoor)//south
							validTile = -1;
						else if (getCell(newx+1, newy) == tileDoor)//west
							validTile = -1;
					}
					
					//if we can, jump out of the loop and continue with the rest
					if (validTile > -1) break;
				}
			}
			if (validTile > -1){
				//choose what to build now at our newly found place, and at what direction
				int feature = getRand(0, 100);
				if (feature <= chanceRoom){ //a new room
					if (makeRoom((newx+xmod), (newy+ymod), 8, 6, validTile)){
						currentFeatures++; //add to our quota
						
						//then we mark the wall opening with a door
						setCell(newx, newy, tileDoor);
						
						//clean up infront of the door so we can reach it
						setCell((newx+xmod), (newy+ymod), tileDirtFloor);
					}
				}
				else if (feature >= chanceRoom){ //new corridor
					if (makeCorridor((newx+xmod), (newy+ymod), 6, validTile)){
						//same thing here, add to the quota and a door
						currentFeatures++;
						
						setCell(newx, newy, tileDoor);
					}
				}
			}
		}
		
		
		/*******************************************************************************
		  All done with the building, let's finish this one off
		 *******************************************************************************/
		
		//sprinkle out the bonusstuff (stairs, chests etc.) over the map
		int newx = 0;
		int newy = 0;
		int ways = 0; //from how many directions we can reach the random spot from
		int state = 0; //the state the loop is in, start with the stairs
		while (state != 10){
			for (int testing = 0; testing < 1000; testing++){
				newx = getRand(1, xsize-1);
				newy = getRand(1, ysize-2); //cheap bugfix, pulls down newy to 0<y<24, from 0<y<25
				
				//System.out.println("x: " + newx + "\ty: " + newy);
				ways = 4; //the lower the better
				
				//check if we can reach the spot
				if (getCell(newx, newy+1) == tileDirtFloor || getCell(newx, newy+1) == tileCorridor){
					//north
					if (getCell(newx, newy+1) != tileDoor)
						ways--;
				}
				if (getCell(newx-1, newy) == tileDirtFloor || getCell(newx-1, newy) == tileCorridor){
					//east
					if (getCell(newx-1, newy) != tileDoor)
						ways--;
				}
				if (getCell(newx, newy-1) == tileDirtFloor || getCell(newx, newy-1) == tileCorridor){
					//south
					if (getCell(newx, newy-1) != tileDoor)
						ways--;
				}
				if (getCell(newx+1, newy) == tileDirtFloor || getCell(newx+1, newy) == tileCorridor){
					//west
					if (getCell(newx+1, newy) != tileDoor)
						ways--;
				}
				
				if (state == 0){
					if (ways == 0){
						//we're in state 0, let's place a "upstairs" thing
						setCell(newx, newy, tileUpStairs);
						state = 1;
						break;
					}
				}
				else if (state == 1){
					if (ways == 0){
						//state 1, place a "downstairs"
						setCell(newx, newy, tileDownStairs);
						state = 10;
						break;
					}
				}
			}
		}
		
		
		//all done with the map generation, tell the user about it and finish
		//printf("%s %d\n",msgNumObjects.c_str(), currentFeatures);
		
		return true;
	}
	
	void cmain()
	{
		int x = 80;
		int y = 25;
		int dungeon_objects = 100;
		dungeon_map = new int[x * y];
		FILE* fp;
//		fp=fopen("maze.txt","w");
		for(;;)
		{
			if(createDungeon(x, y, dungeon_objects))
				showDungeon();
//			for(int i=0;i<ymax;i++){
//				fprintf(fp,"%d",dungeon_map[i*xmax]);
//				for(int j=1;j<xmax;j++){
//					fprintf(fp," %d",dungeon_map[i*xmax+j]);
//				}
//				fprintf(fp,"\n");
//			}
//			fclose(fp);
					fp=fopen("maze.txt","w");
			for(int i=0;i<ymax;i++){
				for(int j=0;j<xmax;j++){
					fprintf(fp,"%d ",dungeon_map[i*xmax+j]);
				}
				fprintf(fp,"\n");
			}
			fclose(fp);
			std::cin.get();
		}
	}
public:
	Dungeon()
	{
		xmax = 80;
		ymax = 25;
		
		xsize = 0;
		ysize = 0;
		
		objects = 0;
		
		chanceRoom = 75;
		chanceCorridor = 25;
		
		msgXSize = "X size of dungeon: \t";
		msgYSize = "Y size of dungeon: \t";
		msgMaxObjects = "max # of objects: \t";
		msgNumObjects = "# of objects made: \t";
		msgHelp = "";
		msgDetailedHelp = "";
		
		cmain();
	}
};

int main()
{
	Dungeon d;
	
	return EXIT_SUCCESS;
}

 然后是地牢文件读取代码

和maze.txt放在一起

#include <stdio.h>
#include <windows.h>

//https://blog.csdn.net/qq_48974566/article/details/131348187
//颜色宏定义
#define NONE         "\033[m"
#define RED          "\033[0;32;31m"
#define LIGHT_RED    "\033[1;31m"
#define GREEN        "\033[0;32;32m"
#define LIGHT_GREEN  "\033[1;32m"
#define BLUE         "\033[0;32;34m"
#define LIGHT_BLUE   "\033[1;34m"
#define DARY_GRAY    "\033[1;30m"
#define CYAN         "\033[0;36m"
#define LIGHT_CYAN   "\033[1;36m"
#define PURPLE       "\033[0;35m"
#define LIGHT_PURPLE "\033[1;35m"
#define BROWN        "\033[0;33m"
#define YELLOW       "\033[1;33m"
#define LIGHT_GRAY   "\033[0;37m"
#define WHITE        "\033[1;37m"


struct queue {
	int num;
	int pre;
};


class Dungeon {
	int xmax;
	int ymax;
	int xsize;
	int ysize;
	int chanceRoom;
	int chanceCorridor;
	int* dungeon_map;
	int* way_map;
	queue* qu;
	int downx;
	int downy;
	int upx;
	int upy;
	
	enum {
		tileUnused = 0,
		tileDirtWall = 1,
		tileDirtFloor = 2,
		tileStoneWall = 3,
		tileCorridor = 4,
		tileDoor = 5,
		tileUpStairs = 6,
		tileDownStairs = 7,
		tileChest = 8,
		tileFind = 9,
		tilePath = 10
	};
	
	void setCell(int x, int y, int celltype) {
		dungeon_map[x + xsize * y] = celltype;
	}
	
	int getCell(int x, int y) {
		return dungeon_map[x + xsize * y];
	}
	
	void showDungeon() {
		for (int y = 0; y < ysize; y++) {
			for (int x = 0; x < xsize; x++) {
				//System.out.print(getCell(x, y));
				switch (getCell(x, y)) {
				case tileUnused:
					printf(" ");
					break;
				case tileDirtWall:
					printf("#");
					break;
				case tileDirtFloor:
					printf(BLUE "." NONE);
					break;
				case tileStoneWall:
					printf("X");
					break;
				case tileCorridor:
					printf(".");
					break;
				case tileDoor:
					printf("+");
					break;
				case tileUpStairs:
					upx = x;
					upy = y;
					printf("<");
					break;
				case tileDownStairs:
					printf(">");
					downx = x;
					downy = y;
					break;
				case tileChest:
					printf("*");
					break;
				};
			}
			printf("\n");
		}
	}
	
	void cmain() {
		
		int x = 80;
		int y = 25;
		xsize = x;
		ysize = y;
		int dungeon_objects = 100;
		dungeon_map = new int[x * y];
		
		FILE* fp;
		fp = fopen("maze.txt", "r");
		if (fp == NULL) {
			printf("打开失败\n");
		}
		for (int i = 0; i < ymax; i++) {
			for (int j = 0; j < xmax; j++) {
				fscanf(fp, "%d ", &dungeon_map[i * xmax + j]);
			}
			fscanf(fp, "\n");
		}
		fclose(fp);
		
		fp = fopen("find.txt", "w");
		for (int i = 0; i < ymax; i++) {
			for (int j = 0; j < xmax; j++) {
				fprintf(fp, " %d", dungeon_map[i * xmax + j]);
			}
			fprintf(fp, "\n");
		}
		fclose(fp);
		system("cls");
//		FILE* fp;	
		while (1) {
			showDungeon();
			BFS();
			getchar();
			
			
		
			fp = fopen("maze.txt", "r");
			if (fp == NULL) {
				printf("打开失败\n");
			}
			for (int i = 0; i < ymax; i++) {
				for (int j = 0; j < xmax; j++) {
					fscanf(fp, "%d ", &dungeon_map[i * xmax + j]);
				}
				fscanf(fp, "\n");
			}
			fclose(fp);
			
			fp = fopen("find.txt", "w");
			for (int i = 0; i < ymax; i++) {
				for (int j = 0; j < xmax; j++) {
					fprintf(fp, " %d", dungeon_map[i * xmax + j]);
				}
				fprintf(fp, "\n");
			}
			fclose(fp);
		}
		
	}
	
	
public:
	Dungeon() {
		xmax = 80;
		ymax = 25;
		xsize = 0;
		ysize = 0;
		cmain();
	}
	
	void displaypath(int front) {
		
		int i, j;
		int k = front;
		for (i = 0; i < ymax; i++)
			for (j = 0; j < xmax; j++)
				if (way_map[i * xmax + j] == tileFind) {}
		way_map[i * xmax + j] == tileDirtFloor;
		
		while (k != -1) {
			way_map[qu[k].num] = tilePath;
			k = qu[k].pre;
		}
		
		for (int i = 0; i < ymax; i++) {
			for (int j = 0; j < xmax; j++) {
				if (way_map[i * xmax + j] == tilePath) {
					printf(RED "~" NONE);
				} else {
					int y = i;
					int x = j;
					switch (getCell(x, y)) {
					case tileUnused:
						printf(" ");
						break;
					case tileDirtWall:
						printf("#");
						break;
					case tileDirtFloor:
						printf(".");
						break;
					case tileStoneWall:
						printf("X");
						break;
					case tileCorridor:
						printf(".");
						break;
					case tileDoor:
						printf(BLUE "+" NONE);
						break;
					case tileUpStairs:
						printf("<");
						break;
					case tileDownStairs:
						printf(">");
						break;
					case tileChest:
						printf("*");
						break;
					};
				}
			}
			printf("\n");
		}
	}
	
	
	void BFS() {
		int H[4] = {0, 1, 0, -1};									// 水平偏移量，下标对应方位号 0~4
		int V[4] = {-1, 0, 1, 0};									// 垂直偏移量
		way_map = new int[xmax * ymax];
		qu = new queue[xmax * ymax];
		memcpy(way_map, dungeon_map, xmax * ymax * sizeof(int));
		int front = -1;
		int rear = -1;
		int x = upx;
		int y = upy;
		int check = y * xmax + x;
		printf("起点up  x,y=%d %d\n", x, y);
		printf("终点downx,y=%d %d\n", downx, downy);
		
		rear++;
		qu[rear].num = check;
		qu[rear].pre = -1;
		while (front != rear) {
			front++;
			check = qu[front].num;
			if (dungeon_map[check] == tileDownStairs) {
				displaypath(front);
				break;
			}
			for (int k = 0; k < 4; k++) {
				int checkv2 = check + V[k] * xmax + H[k];
				if (way_map[checkv2] != tileFind
					&& way_map[checkv2] % xmax > 0 && checkv2 % xmax < xmax - 1 && checkv2 / xmax > 0 && checkv2 / xmax < ymax - 1
					&& (way_map[checkv2] == tileDownStairs || way_map[checkv2] == tileDirtFloor || way_map[checkv2] == tileCorridor || way_map[checkv2] == tileDoor)) {
					
					way_map[checkv2] = tileFind;				// 改为‘*’tileFind 避免重复查找
					int pre = front;
					rear++;
					qu[rear].num = checkv2;
					qu[rear].pre = pre;								// 方块 2 进队
				}
			}
		}
	}
};


int main() {
	
	Dungeon d;
	
	return 0;
	
}

a1309602336
关注
  • 9
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三种算法实现迷宫自动寻路（C++实现 鼠标点击 含源码）
SBXDXG的博客
12-21 2493
三种算法实现迷宫自动寻路（C++实现 鼠标点击 含源码）
迷宫自动寻路
11-24
win32 知识简单实现迷宫自动寻路,使用stack模板实现的实现的算法
迷宫生成及自动寻路--DFS算法
m0_53695433的博客
01-24 644
该项目应用于计算机软件课设。该项目主要分成两部分迷宫生成与自动寻路，两部分都采用DFS算法。该项目实现难度不大，没有采用较难的算法，BFS寻路以及A*寻路都未实现，留待后续完善。
迷宫自动寻路C语言,迷宫自动生成以及基于DFS的自动寻路算法
weixin_39853210的博客
05-19 766
直接贴代码#include#include#include#include#include#include#include#include#include#include #include #include using namespace std;#define max 50#define x_max max#define y_max maxint map[x_max][y_max];#defin...
自动生成迷宫和迷宫自动寻路OpenGL版（源代码+演示程序）
12-14
大学二年级的时候，作为对栈这个数据结构的复习，我制作了一个迷宫生成算法的小程序，当时反响十分好，过了几天我又用自己已经学的DirectX技术制作了DirectX版的程序。这几天回过头看自己的文章，感觉温故而知不足。温故是因为唤醒了我对迷宫算法的回忆，知不足是因为我那个程序一点儿也没有按照面向对象的思路去做。还是那一套C的思想。 我打算重新制作迷宫程序。这次和以前不同，我学习了C++、STL、Lua、OpenGL，还有很多很多对游戏开发很实用的知识。因此我打算将自己的迷宫重新写一遍，使用面向对象的思想。
基于递归分割的迷宫生成算法与自动寻路
08-01
本项目实现了一个基于递归分割迷宫和自动寻路的java可视化，相应博客地址为：http://blog.csdn.net/yutianzuijin/article/details/52078340
迷宫的生成与自动寻路
12-06
迷宫的生成与自动寻路; 详细的介绍了迷宫的生成，还有求解。 代码有注释 好好学习天天向上 希望大家珍惜大学时光
基于C#和Unity的迷宫自动生成源码.zip
08-09
基于C#和Unity的迷宫自动生成源码 基于C#和Unity的迷宫自动生成源码 基于C#和Unity的迷宫自动生成源码 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合...
基于Java Swing的迷宫随机生成 + 自动寻路 demo(附源码)
01-06
最近学到A星寻路算法，觉得颇有意思，于是百度Google，花了2天时间捣鼓出一个基于Swing的可视化迷宫生成和寻路demo。在此做个记录~ 小demo使用的迷宫生成算法是DFS，寻路用的A星。这样以来，生成的迷宫任意2个格子...
自动生成迷宫并寻路(无模块)
05-27
1.定义迷宫节点 10*10的方格。 2.定义墙 每道墙都会有两个相连的迷宫节点。 3.每个迷宫节点都有4道墙,如果靠近了边界,则设置为-1（画图时只有>0的墙体才会被画出）。 4.从地图所有节点中挑出一个节点作为迷宫的...
迷宫生成算法和迷宫寻路算法
架构设计
12-14 1067
&lt;style type="text/css"&gt; &lt;!-- @page {margin:2cm} pre.cjk {font-family:"DejaVu Sans Condensed",monospace} p {margin-bottom:0.21cm} --&gt; &lt;/style&gt; 迷宫生成算法和迷宫寻路算法 大学二年级的时候，作为对栈...
Android DataBinding从入门到精通
Dream的博客
07-22 1103
DataBinding可以更加方便的编写与视图交互的代码。即系统会为模块中的每个xml文件生成一个绑定类，其实例包含指向相应布局中具有ID的所有视图的直接引用。大多数情况下，DataBinding会代替findMyId。
蚂蚁集团Android一面凉经(2024)
最新发布
景三的专栏
07-25 186
笔者作为一名双非二本毕业7年老Android, 最近面试了不少公司, 目前已告一段落, 整理一下各家的面试问题, 打算陆续发布出来, 供有缘人参考。今天给大家带来的是《蚂蚁集团Android一面凉经(2024)》。
uniapp安卓通过绝对路径获取文件
qq_61950936的博客
07-23 259
请确保你的uniapp应用具有读取存储的权限，并且该文件确实存在于指定的路径。此外，你的应用可能需要运行在Android 4.4及以上版本的设备上，因为plus.io API是基于HTML5 Plus的，而这个特性需要设备的Android版本和浏览器支持。在uniapp中，如果你想要访问安卓设备上的文件，你需要使用uniapp提供的plus.io API。这个API允许你在应用内访问设备的文件系统。
Android 通过接收广播int值来控制GPS开关
qq_46687516的博客
07-25 372
Override} else {try {
Android 多用户问题
m0_54010212的博客
07-22 343
在工程模式下，可以使用 getInstalledPackages 或 getInstalledPackagesAsUser 方法获取全部已安装的应用程序，并展示给用户。List<MediaController> 在普通应用中可以获取到，但是在systemUI中获取不到。这个api解决 那为什么systemUI在 0这个组别？在systemserver 里启动的组别就是这个。音频mediassion相关是区分用户的。看了一下是 user组别问题导致的。那么还有没有什么是区别用户的。当然有 PMS也是这样。
【23】Android高级知识之Window(四) - ThreadedRenderer
mr_zengkun的博客
07-21 1097
ThreadedRenderer、WMS
用C++写一个迷宫代码，要求自动生成迷宫并且可以自动寻路
05-20
以下是使用C++语言生成迷宫并自动寻路的示例代码： ```cpp #include #include #include #include #include using namespace std; const int MAX_ROW = 20; const int MAX_COL = 20; const int WALL = 1; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值