走迷宫 A*算法 广度优先算法

最新推荐文章于 2025-04-14 12:00:14 发布
最新推荐文章于 2025-04-14 12:00:14 发布
阅读量3.1k 收藏 3
点赞数
分类专栏： Game C/C++ Algorithm/Data structure Windows 文章标签： 算法 struct null insert search ttf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EvilBinary_root/article/details/6618197
版权

走迷宫 A*  算法 广度优先

走迷宫 A* 和广度算法 SDL库
A* 算法 SDL  
 

//小E  EvilBinary  QQ592646022 
代码：
#ifndef _MAZE_H
#define _MAZE_H
#include "sdl.h"
#include "sdl_ttf.h"

#define MAZEROW 20
#define MAZECOL 25

extern const int SCREEN_WIDTH;
extern const int SCREEN_HEIGHT ;
extern const int SCREEN_BPP;


extern SDL_Surface *background;
extern SDL_Surface *screen ;
extern SDL_Event event;
extern SDL_Surface *message ;
extern SDL_Surface *upMessage;
extern SDL_Surface *downMessage;
extern SDL_Surface *leftMessage;
extern SDL_Surface *rightMessage ;

extern SDL_Thread *thread ;
extern SDL_Surface *stepbmp;
extern SDL_Surface *block;
extern SDL_Surface *noblock;
extern TTF_Font *font;
extern SDL_Color textColor ;

extern SDL_Surface *startimg ;
extern SDL_Surface *endimg ;

extern int map[MAZEROW][MAZECOL];			//地图

extern int startx;				//开始坐标
extern int starty;				//
extern int endx;				//结束坐标
extern int endy;
extern int step;					//走的步数
extern int searchway;

extern int drawx;
extern int drawy;

extern bool quit ;
extern bool traceflage;
extern bool searchfinishflage;
extern bool drawpathflage;
extern bool isfirstdrawflage;

extern bool leftbtnflage;
extern bool rightbtnflage;

extern struct node* opentable ;
extern struct node* closetable ;

struct node {
	int x;
	int y;
	int fn;
	int step;
	struct node* parent;
	struct node* next;
};


void init();
void make_map();
void make_random_map();
int evaluate(int x,int y,int s);
void print_map();
void insert_opentable(struct node* node);
void insert_closetable(struct node* node);
struct node* remove_opentable(struct node* node);
bool is_in_closetable(struct node* node);

void save_map();
void read_map();

void clear_opentable();
void clear_closetable();

void print_closetable();
void print_opentable();
void new_opennode();

void do_search();
void do_astart_search();
void do_wide_search();
void do_deep_search();


void draw_map();
void draw_trace();
void draw_path();

void clear_map();
void print_help();
void apply_surface(int x,int y,SDL_Surface* source,SDL_Surface* destination,SDL_Rect* clip);
bool init_sdl();
void clean_up();
void key_process();
int my_thread( void *data );
SDL_Surface *load_image(char* filename);
bool load_files();


#endif
#include "maze.h"
#include "sdl_ttf.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>


void make_map(){
	for(int i=0;i<MAZEROW;i++){
		for(int j=0;j<MAZECOL;j++){
			map[i][j]=0;
		}
	}
	map[0][1]=1;
	map[1][1]=1;
	map[1][6]=1;
	//map[1][7]=1;
	
	map[0][2]=1;
	map[4][0]=1;
	map[7][1]=1;
	map[3][6]=1;
	map[2][7]=1;
	map[3][6]=1;
	map[4][6]=1;
	map[5][6]=1;
	map[7][6]=1;
	//map[7][5]=1;
	map[6][6]=1;
	//map[2][2]=1;
	//map[2][3]=1;
	map[2][4]=1;
	map[2][6]=1;
	map[2][7]=0;
	
	map[3][2]=1;
	map[3][3]=1;
	map[3][4]=1;
	
	map[4][2]=1;
	//map[4][3]=1;
	map[4][4]=1;
	
	//map[5][2]=1;
	map[5][3]=1;
	map[5][4]=1;
	
	//map[6][2]=1;
	map[6][3]=1;
	map[6][4]=1;
	
	for(  i=1;i<=19;i++){
		map[i][18]=1;
	}
	for(  i=0;i<19;i++){
		map[i][16]=1;
	}
	
	for(  i=7;i<16;i++){
		map[7][i]=1;
	}
	for(  i=8;i<16;i++){
		map[i][10]=1;
	}
	//make_random_map();
}

void make_random_map(){
	//srand(time(0));
	int a=rand()%2;
	for(int i=0;i<MAZEROW;i++){
		for(int j=0;j<MAZECOL;j++){
			if(rand()%2==0){
				map[i][j]=rand()%2;
			}else{
				
				map[i][j]=0;
			}
			
		}
	}
	
	endy=MAZEROW-1;
	endx=MAZECOL-1;
	map[starty][startx]=0;
	map[endy][endx]=0;
	
}
void init(){
	step=0;
	endy=MAZEROW-1;
	endx=MAZECOL-1;
	map[starty][startx]=0;
	map[endy][endx]=0;
	make_map();
	//make_random_map();
}

int evaluate(int x,int y,int s){
	int xx=abs(endx-x);
	int yy=abs(endy-y);
	return xx+yy+s;
	//return xx*xx+yy*yy+s*s;
	
}

void print_map(){
	for(int i=0;i<MAZEROW;i++){
		for(int j=0;j<MAZECOL;j++){
			printf("%d ",map[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}


void insert_opentable(struct node* node){
	struct node* tmp=opentable;
	if(opentable==NULL){	//没有节点的时候
		opentable=node;
	}else{
		if(tmp->next==NULL){	//有1个
			if(node->fn<tmp->fn){
				node->next=tmp;
				opentable=node;
			}else{
				tmp->next=node;
			}
		}else{
			if(node->fn<tmp->fn){
				node->next=tmp;
				opentable=node;
			}else{
				while(tmp->next!=NULL){
					if(node->fn<tmp->next->fn){
						node->next=tmp->next;
						tmp->next=node;
						return;
					} 
					tmp=tmp->next;
				}
				tmp->next=node;
			}
		}
	}
	
	
}

void insert_opentable_wide(struct node* node){
	node->fn=node->step;
	struct node* tmp=opentable;
	if(opentable==NULL){	//没有节点的时候
		opentable=node;
	}else{
		if(tmp->next==NULL){	//有1个
			if(node->fn<tmp->fn){
				node->next=tmp;
				opentable=node;
			}else{
				tmp->next=node;
			}
		}else{
			if(node->fn<tmp->fn){
				node->next=tmp;
				opentable=node;
			}else{
				while(tmp->next!=NULL){
					if(node->fn<tmp->next->fn){
						node->next=tmp->next;
						tmp->next=node;
						return;
					} 
					tmp=tmp->next;
				}
				tmp->next=node;
			}
		}
	}
	
	
}



struct node* remove_opentable(struct node* node){
	struct node* tmp=opentable;
	if(opentable==NULL){	//没有节点的时候
		return NULL;
	}else{
		if(tmp->next==NULL){	//有1个
			if(node->x==tmp->x&&node->y==tmp->y){
				opentable=NULL;
				return tmp;	
			}else{
				return NULL;
			}
		}else{
			if(node->x==tmp->x&&node->y==tmp->y){	//有两个
				opentable=tmp->next;
				tmp->next=NULL;
				return tmp;		 
			}else{
				while (tmp->next!=NULL) {
					if(node->x==tmp->next->x&&node->y==tmp->next->y){
						struct node* tnext=tmp->next;
						tmp->next=tmp->next->next;
						tnext->next=NULL;
						return tnext;
						break;
					}
					tmp=tmp->next;
				}
				return tmp;	
			}
		}
	}
	return tmp;
}

bool is_in_opentable(struct node* node){
	struct node* tmp=opentable;
	while (tmp!=NULL) {
		if(tmp->x==node->x&&tmp->y==node->y){
			return true;
		}
		tmp=tmp->next;
	}
	return false;
}

void insert_closetable(struct node* node){
	struct node* tmp=closetable;
	if(closetable==NULL){
		closetable=node;
	}else{
		if(tmp->next==NULL){	
			tmp->next=node;
		}else{
			while (tmp->next!=NULL) {
				tmp=tmp->next;
			}
			tmp->next=node;
		}
	}
	
}
bool is_in_closetable(struct node* node){
	struct node* tmp=closetable;
	while (tmp!=NULL) {
		if(tmp->x==node->x&&tmp->y==node->y){
			return true;
		}
		tmp=tmp->next;
	}
	return false;
}
void remove_closetable(struct node* node){
	
}

void clear_opentable(){//未实现
	struct node* tmp=opentable;
	while (tmp!=NULL) {
		
		
		tmp=tmp->next;
	}
	opentable=NULL;	
}
void clear_closetable(){//未实现
	struct node* tmp=closetable;
	while (tmp!=NULL) {
		
		
		tmp=tmp->next;
	}
	closetable=NULL;	
}

void print_opentable(){
	struct node* tmp=opentable;
	int count=0;
	while (tmp!=NULL) {
		printf("%d[%d,%d] ",tmp->fn,tmp->y,tmp->x);
		count++;
		tmp=tmp->next;
	}
	printf("Open Table count=%d\n",count);
}

void print_closetable(){
	int count=0;
	struct node* tmp=closetable;
	while (tmp!=NULL) {
		printf("%d[%d,%d] ",tmp->fn,tmp->y,tmp->x);
		count++;
		tmp=tmp->next;
	}
	printf("Close Table count=%d\n",count);
}


void new_opennode(){
	struct node* head=new struct node;
	head->fn=opentable->fn;
	head->next=NULL;
	head->x=opentable->x;
	head->y=opentable->y;
	head->step=opentable->step;
	head->parent=opentable->parent;
	
	struct node* tt=remove_opentable(head);

	insert_closetable(tt);	 
 
	
	//left
	if (head->x>0&&head->x<=(MAZECOL-1)&&map[head->y][head->x-1]!=1){
		struct node *left=new struct node;
		left->fn=evaluate(head->x-1,head->y,head->step);
		left->x=head->x-1;
		left->y=head->y;
		left->step=step;
		left->parent=head;
		left->next=NULL;
		if(!is_in_closetable(left)&&!is_in_opentable(left)){
			switch(searchway){
			case 0:
				insert_opentable(left);			//A* 算法搜索插入排序
				break;
			case 1:								//广度搜索插入排序
				insert_opentable_wide(left);
				break;
			case 2:								//深度搜索插入排序
				break;
			}
		}
			
	}
	//right
	if(head->x>=0&&head->x<(MAZECOL-1)&&map[head->y][head->x+1]!=1){
		struct node *right=new struct node;
		right->fn=evaluate(head->x+1,head->y,head->step);
		right->x=head->x+1;
		right->y=head->y;
		right->step=step;
		right->parent=head;
		right->next=NULL;
		if(!is_in_closetable(right)&&!is_in_opentable(right)){
			switch(searchway){
			case 0:
				insert_opentable(right);			//A* 算法搜索插入排序
				break;
			case 1:								//广度搜索插入排序
				insert_opentable_wide(right);
				break;
			case 2:								//深度搜索插入排序
				break;
			}
		}
		
	}
	//up
	if(head->y>0&&head->y<=(MAZEROW-1)&&map[head->y-1][head->x]!=1){
		struct node *up=new struct node;
		up->fn=evaluate(head->x,head->y-1,head->step);
		up->x=head->x;
		up->y=head->y-1;
		up->step=step;
		up->parent=head;
		up->next=NULL;
		if(!is_in_closetable(up)&&!is_in_opentable(up)){
				switch(searchway){
			case 0:
				insert_opentable(up);			//A* 算法搜索插入排序
				break;
			case 1:								//广度搜索插入排序
				insert_opentable_wide(up);
				break;
			case 2:								//深度搜索插入排序
				break;
			}
		}
		
		
	} 
	//down
	if(head->y>=0&&head->y<(MAZEROW-1)&&map[head->y+1][head->x]!=1){
		struct node* down=new struct node;
		down->fn=evaluate(head->x,head->y+1,head->step);
		down->x=head->x;
		down->y=head->y+1;
		down->step=step;
		down->parent=head;
		down->next=NULL;
		if(!is_in_closetable(down)&&!is_in_opentable(down)){
				switch(searchway){
			case 0:
				insert_opentable(down);			//A* 算法搜索插入排序
				break;
			case 1:								//广度搜索插入排序
				insert_opentable_wide(down);
				break;
			case 2:								//深度搜索插入排序
				break;
			}
		}
		
	}	
	
	
}



void do_search(){
	bool successflage=false;
	struct node* t=new struct node;
	t->x=startx;
	t->y=starty;
	t->fn=evaluate(startx,starty,step);
	t->step=step;
	t->next=NULL;
	t->parent=NULL;
	insert_opentable(t);
	
	while (true) {
		new_opennode();
		if(opentable==NULL){
			successflage=false;
			break;
		}
		//SDL_Delay( 200 );
		//draw_trace();
		if(opentable->x==endx&&opentable->y==endy){
			new_opennode();
			print_opentable();
			
			printf("\n\n");
			successflage=true;
			break;
		}
		/*	
		printf("Open Table\n");
		print_opentable();
		printf("\n\nClose Table\n");
		print_closetable();
		printf("\n\n");
		*/
		step++;
		if(step>MAZEROW*800){
			
			printf("Faile too long bug .\n");
			break;
		}
		
	} 
	
	if(successflage==true){
		printf("Close Table step:%d\n",step);
		print_closetable();
		printf("Depth=%d\n",step);
	}else{
		printf("no way step:%d\n",step);
	}
}
void do_astart_search(){
	searchway=0;
}
void do_wide_search(){
	searchway=1;
}
void do_deep_search(){
	searchway=2;
}

void draw_trace(){
	
	struct node* tmp=closetable;
	while (tmp!=NULL) {
		//printf("%d[%d,%d] ",tmp->fn,tmp->y,tmp->x);
		apply_surface(30 +endy*30+endy,30 +endx*30+endx,endimg,screen,NULL);	
		if(tmp->y==starty&&tmp->x==startx){
			apply_surface(30 +starty*30+starty, 30 +startx*30+startx,startimg,screen,NULL);
		} else{
				apply_surface(30+ tmp->x*30+tmp->x,30+  tmp->y*30+tmp->y,stepbmp,screen,NULL);
		}
		
		if(isfirstdrawflage){
			SDL_Delay( 50 );
			if( SDL_Flip( screen ) == -1 )
			{
				return ;    
			}
		}
		
		tmp=tmp->next;
	}
	
	 apply_surface(30 +endx*30+endx,30 +endy*30+endy,endimg,screen,NULL);
	
	
	
}
void draw_path(){
	int countstep=0;
	char msg[20];
	struct node* tmp=closetable;
	if(tmp==NULL)
		return;
	while(tmp->next!=NULL){
		
		tmp=tmp->next;
	}
	tmp=tmp->parent;
	while (tmp!=NULL) {
		//printf("%d[%d,%d] ",tmp->fn,tmp->y,tmp->x);
		if(tmp->y==starty&&tmp->x==startx){
			apply_surface(30 +starty*30+starty, 30 +startx*30+startx,startimg,screen,NULL);
		} else{
			apply_surface(30+ tmp->x*30+tmp->x,30+  tmp->y*30+tmp->y,stepbmp,screen,NULL);
		}
		if(isfirstdrawflage){
			SDL_Delay( 100 );
			
			if( SDL_Flip( screen ) == -1 )
			{
				return ;    
			}
		}
		countstep++;
		tmp=tmp->parent;
	}
	
	sprintf(msg,"countstep=%d",countstep);
	message=TTF_RenderText_Solid( font,msg, textColor );
	apply_surface(30 +endx*30+endx,30 +endy*30+endy,endimg,screen,NULL);
}





void apply_surface(int x,int y,SDL_Surface* source,SDL_Surface* destination,SDL_Rect* clip){
	SDL_Rect offset;
	offset.x=x;
	offset.y=y;
	SDL_BlitSurface(source,clip,destination,&offset);
}

bool init_sdl(){
	//Initialize all SDL subsystems
    if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
    {
        return false;    
    }
    
    //Set up the screen
    screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
    
    //If there was an error in setting up the screen
    if( screen == NULL )
    {
        return false;    
    }
    
    //Initialize SDL_ttf
    if( TTF_Init() == -1 )
    {
        return false;    
    }
    
    //Set the window caption
    SDL_WM_SetCaption( "Maze", NULL );
    
    //If everything initialized fine
	init();
	load_files();
	block=load_image("block.bmp");
	noblock=load_image("noblock.bmp");
	stepbmp=load_image("step.bmp");
	background=load_image("background.bmp");
	startimg=load_image("start.bmp");
	endimg=load_image("end.bmp");
	upMessage =TTF_RenderText_Solid( font, "Do a start search.", textColor );;
	downMessage  =TTF_RenderText_Solid( font, "Do trace.", textColor );;
	leftMessage =TTF_RenderText_Solid( font, "Do clear opentable closetable.", textColor );;
	rightMessage =TTF_RenderText_Solid( font, "Down was pressed.", textColor );
	
	
    return true;
}

void clean_up()
{
    //Free the surfaces
    SDL_FreeSurface( background );
    //SDL_FreeSurface( message );
    
    //Close the font that was used
    TTF_CloseFont( font );
    
    //Quit SDL_ttf
    TTF_Quit();
    
    //Quit SDL
    SDL_Quit();
}


void key_process(){
	
	while ( SDL_WaitEvent(&event) >= 0 ) {
		
        switch (event.type) 
		{
		case SDL_ACTIVEEVENT:
			
			if ( event.active.state & SDL_APPACTIVE ) {
				if ( event.active.gain ) {
					printf("App activated\n");
				} else {
					printf("App iconified\n");
				}
			}
			
			break;
		case SDL_MOUSEMOTION:
			
			if(leftbtnflage){	
				map[drawy][drawx]=1;
				if(!drawpathflage){
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					}
				}
				
				
			}else if(rightbtnflage){
				
				map[drawy][drawx]=0;
				if(!drawpathflage){
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					}
				}
				
				
			}
			drawx=(event.motion.x-30)/31;
			drawy=(event.motion.y-30)/31;
			
			break;
		case SDL_MOUSEBUTTONDOWN: 
			
			Uint8 *keys;
			
			keys = SDL_GetKeyState(NULL);
			if ( keys[SDLK_ESCAPE] == SDL_PRESSED ) {
				printf("Bye bye...\n");
				exit(0);
			}
			if(!drawpathflage)
			{
				
				switch(event.button.button)
				{
				case SDL_BUTTON_LEFT:
					leftbtnflage=true;
					//printf("x:%d y:%d\n",(event.motion.x-30)/31,(event.motion.y-30)/31);
					map[drawy][drawx]=1;
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					} 
					
					
					break;
				case SDL_BUTTON_RIGHT:
					rightbtnflage=true;
					map[drawy][drawx]=0;
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					} 
					break;
					
				}
			}
			break;
		case SDL_MOUSEBUTTONUP: 
			if(!drawpathflage)
			{
				switch(event.button.button)
				{
				case SDL_BUTTON_LEFT:
					leftbtnflage=false;
					//printf("x:%d y:%d\n",(event.motion.x-30)/31,(event.motion.y-30)/31);
					//map[(event.motion.y-30)/31][(event.motion.x-30)/31]=1;
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					} 
					
					
					break;
				case SDL_BUTTON_RIGHT:
					rightbtnflage=false;
					//map[(event.motion.y-30)/31][(event.motion.x-30)/31]=0;
					draw_map();
					if( SDL_Flip( screen ) == -1 )
					{
						return ;    
					} 
					break;
					
				}
			}
			break;
		case SDL_KEYDOWN:
			switch(event.key.keysym.sym) 
			{
			case SDLK_r:
				make_random_map();
				
				printf("Random map...\n");
				clear_opentable();
				clear_closetable();
				step=0;
				message=leftMessage;
				isfirstdrawflage=true;
				drawpathflage=false;
				traceflage=false;
				break;
			case SDLK_m:
				save_map();
				break;
			case SDLK_l:
				read_map();
				break;
			case SDLK_p:
				print_map();
				break;
			case SDLK_c:
				isfirstdrawflage=false;
				break;
			case SDLK_s:
				isfirstdrawflage=true;
				break;
			case SDLK_F1:
				print_help();
				break;
			case SDLK_F2:
				clear_map();
				drawpathflage=false;
				traceflage=false;
				break;
			}
			break;
			case SDL_KEYUP:
				switch( event.key.keysym.sym )
				{
				case SDLK_a: 
					printf("Set as a start search.\n");
					do_astart_search();
					message=upMessage;
					break;
				case SDLK_w:
					printf("Set as a wide search.\n");
					do_wide_search();
					break;
					
				case SDLK_d:
					printf("Set as deep search.\n");
					do_deep_search();
					break;
				case SDLK_g:
					printf("Starting Serach....\n");
					do_search();
					break;
					
				case SDLK_t:  
					printf("Do trace...\n");
					message=downMessage;
					traceflage=true;
					drawpathflage=true;
					break;
				case SDLK_SPACE: 
					printf("Clear opentable closetable...\n");
					clear_opentable();
					clear_closetable();
					step=0;
					message=leftMessage;
					drawpathflage=false;
					isfirstdrawflage=true;
					traceflage=false;
					break;
				case SDLK_x: 
					printf("Draw path...\n");
					drawpathflage=true;
					traceflage=false;
					
					
				}
				//PrintKeyInfo( &event.key );
				break;	
				case SDL_QUIT: {
					printf("Quit requested, quitting.\n");
					exit(0);
							   }
					break;
		}
		
		
		
    }
}

int my_thread( void *data )
{
	
    while( quit == false )
    {
		
        SDL_WM_SetCaption( "Maze is running", NULL );
        SDL_Delay( 10 );
		
		SDL_WM_SetCaption( "Maze is running.", NULL );
		SDL_Delay( 100 );
        
		SDL_WM_SetCaption( "Maze is running..", NULL );
		SDL_Delay( 100);
        
		SDL_WM_SetCaption( "Maze is running...", NULL );
		SDL_Delay( 100 );
		
		apply_surface( 0, 0, background, screen ,NULL);
		if( message != NULL )
		{
			
			apply_surface( 0, 0, message, screen,NULL );	
			message = NULL;
		}
		
		draw_map();
		if(traceflage){
			draw_trace();
			//isfirstdrawflage=false;
			//traceflage=false;
		}else if(drawpathflage){
			draw_path();
			//isfirstdrawflage=false;
			//drawpathflage=false;
		}
		
		if( SDL_Flip( screen ) == -1 )
		{
			return -1;    
		} 
    }
    
    return 0;    
}


void draw_map(){
	for(int i=0;i<MAZEROW;i++){
		for(int j=0;j<MAZECOL;j++){
			if(map[i][j]==0){
				apply_surface(30 +j*30+j, 30 +i*30+i,noblock,screen,NULL);
			}else{
				apply_surface(30 +j*30+j, 30 +i*30+i,block,screen,NULL);
			}
			
			
		}
	}
	apply_surface(30 +endx*30+endx,30 +endy*30+endy,endimg,screen,NULL);
	apply_surface(30 +startx*30+startx, 30 +starty*30+starty,startimg,screen,NULL);
	
	
}

SDL_Surface *load_image(char* filename){
	SDL_Surface* loadedImage=NULL;
	SDL_Surface* optimizedImage=NULL;
	loadedImage=SDL_LoadBMP(filename);
	if(loadedImage!=NULL){
		optimizedImage = SDL_DisplayFormat( loadedImage );
		SDL_FreeSurface( loadedImage );
	}
	return optimizedImage;
	
}


bool load_files()
{
    //Load the background image
    background = load_image( "background.png" );
    
    //Open the font
    font = TTF_OpenFont( "lazy.ttf", 28 );
    
    //If there was a problem in loading the background
    if( background == NULL )
    {
        return false;    
    }
    
    //If there was an error in loading the font
    if( font == NULL )
    {
        return false;
    }
    
    //If everything loaded fine
    return true;    
}

void save_map(){
	printf("Save map in 1.map\n");
	FILE *fp;
    if((fp=fopen("1.map","wb"))==NULL)
    {
        printf("can not open file.\n");
		
        return;
    }
	for(int i=0;i<MAZECOL;i++){
		for(int j=0;j<MAZEROW;j++){
			fprintf(fp,"%d ",map[i][j]);
		}
		fprintf(fp,"\n");
	}
	
	fclose(fp);
	
}
void read_map(){
	printf("Open map 1.map\n");
	FILE *fp;
    if((fp=fopen("1.map","rb"))==NULL)
    {
        printf("can not open file.\n");
		
        return;
    }
	for(int i=0;i<MAZECOL;i++){
		for(int j=0;j<MAZEROW;j++){
			fscanf(fp,"%d ",map[i][j]);
		}
		fscanf(fp,"\n");
	}
	
	fclose(fp);
}

void print_help(){
	printf("=====================\n");
	printf("Key function table\n");
	printf("F1	help\n");
	printf("F2  clear map\n");
	printf("D	deep search\n");
	printf("A	a start search\n");
	printf("W	wide search\n");
	printf("S	step \n");
	printf("C	coninue\n");
	printf("L	load map\n");
	printf("M	save map\n");
	printf("SPASE clear tables and flags\n");
	printf("R	random map\n");
	printf("P	print map\n");
	printf("T	trace \n");
	printf("X	draw path\n");
	printf("G	go for search\n");
	printf("=====================\n\n");
}

void clear_map(){
	for(int i=0;i<MAZEROW;i++){
		for(int j=0;j<MAZECOL;j++){
			map[i][j]=0;
		}
	}
}


#include <stdio.h>
#include <stdlib.h>
#include "maze.h"
#include "sdl.h"
#include "sdl_ttf.h"

/****************************
	key function table
	F1  help
	F2 clear map
	D	deep search
	A	a start search
	W	wide search
	S	step 
	C	coninue
	L	load map
	M	save map
	SPASE clear tables and flags
	R	random map
	P	print map
	T	trace 
	X	draw path
	G	go for search
*****************************/

const int SCREEN_WIDTH = 900;
const int SCREEN_HEIGHT = 700;
const int SCREEN_BPP = 32;
 

SDL_Surface *background = NULL;
SDL_Surface *screen = NULL;
SDL_Surface *message = NULL;

SDL_Surface *upMessage =NULL;
SDL_Surface *downMessage  =NULL;
SDL_Surface *leftMessage =NULL;
SDL_Surface *rightMessage =NULL;
SDL_Event event;

TTF_Font *font = NULL;
SDL_Thread *thread = NULL;

SDL_Color textColor = { 0, 0xff, 0 };

SDL_Surface *stepbmp=NULL;
SDL_Surface *block=NULL;
SDL_Surface *noblock=NULL;
SDL_Surface *startimg=NULL;
SDL_Surface *endimg=NULL;

struct node* opentable=NULL;
struct node* closetable=NULL;
int map[MAZEROW][MAZECOL];
int startx;
int starty;
int endx;
int endy;
int step;
int searchway=0;

int drawx;
int drawy;

bool quit = false;
bool traceflage=false;
bool drawpathflage=false;
bool searchfinishflage=false;
bool isfirstdrawflage=true;
bool leftbtnflage=false;
bool rightbtnflage=false;

int main(int argc,char* argv[]){
	
	init_sdl();
	draw_map();
	if( SDL_Flip( screen ) == -1 )
	{
		return -1;    
	} 

	init();
	print_map();
	draw_map();
	
	thread = SDL_CreateThread( my_thread, NULL );
    key_process();

	return 0;
}

A*算法实现走迷宫（可应用于游戏人物自动寻路）
s_p_y_s的博客
10-24 8516
环境：win10   语言: Python3.6   编译器：pycharm 先看效果图（红色：终点  黄色：起点   黑色：障碍  绿色路径） 一、A*算法： A*算法是一种启发式搜索算法，它不需遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。它的独特之处是检查最短路径中每个可能的节点时引入了全局信息，对当前节点距终点...
算法浅谈——走迷宫问题与广度优先搜索
TechFlow的博客
03-12 526
本文始发于个人公众号：TechFlow，原创不易，求个关注 在之前周末LeetCode专栏当中，我们详细描述了深度优先搜索和回溯法，所以今天我们继续这个话题，来和大家聊聊搜索算法的另一个分支，广度优先搜索。 广度优先搜索的英文是Breadth First Search，简写为bfs。与它相对的深度优先搜索，英文自然就是Depth First Search，简写成dfs。所以如果在阅读我或者其他人...
基于A*算法的走迷宫程序
10-25
这是我在网络上看到的一个用A*算法写的走迷宫程序，拿出来跟大家一块分享作者的作品。
A*算法求解迷宫寻路问题（启发式算法）
12-04
入口坐标和出口坐标分别为(startx,starty)和(endx,eny)，每一个坐标点有两种可能：0或1，其中0表示该位置允许通过，1表示该位置不允许通过。以寻路问题为例实现A*算法的求解程序，设计两种不同的估价函数。
迷宫 a*算法实现
02-07
迷宫 a*算法实现
深度广度优先算法、A*算法
八爪大头鱼
08-19 5805
深度广度优先算法、A*算法深度优先算法（DFS）实现步骤实现代码广度优先算法（BFS）实现步骤实现代码A*算法Dijkstra算法A*算法介绍实现流程实现过程实现代码 深度优先算法（DFS） 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆数据结构来辅助实现DFS算法。其过程简要来说是
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
C语言使用广度优先搜索算法解决迷宫问题（队列） 本文主要介绍了C语言使用广度优先搜索算法解决迷宫问题的相关知识点，详细解释了C语言队列广度优先搜索算法的使用技巧和实现细节。 一、广度优先搜索算法的基本...
实验三：基于A*算法的迷宫
qq_48016569的博客
12-14 2362
实验要求： 1、迷宫随机生成 2、玩家走迷宫，留下足迹； 3、系统用A*算法寻路，输出路径 解决问题： 1、如何显示迷宫的图形界面； 2、如何生成随机的迷宫； 3、怎样移动游戏中走迷宫的“玩家”； 4、用A*算法求解迷宫；一、生成迷宫的图形界面 利用JavaGUI进行图形界面设计 ...
迷宫寻路之广度优先算法（bfs）
最新发布
2301_77726810的博客
04-14 1720
简短介绍了深度优先算法（df）用于迷宫寻路，但深度优先算法具有随机性，而且找到的路不一定是最短的路径。上文括号里的参数，例如（3，1，4），3行，1为列，4为到达的最短步数。这里我们从（0，0）出发到到（2，2）位置，最少需要4步。if (q->front > q->rear) { // 队列为空时重置。//maze 表示迷宫，0表示可以通行，1表示不可以通行。//这里是path的索引。通过标注，我们可以清楚的知道最短路径。下面是通过c写的相关实现。// 队列结构用于BFS。// 检查队列是否为空。
迷宫寻路问题——A*算法
热门推荐
DiamonJoy
03-24 2万+
迷宫寻路问题是人工智能中的有趣问题，如何表示状态空间和搜索路径是寻路问题的重点，本文的主要内容是A*搜索算法的理解和应用，首先对基本知识和算法思想进行了解，再通过其对迷宫问题求解应用，编写 Python 程序进行深入学习。
基于A*算法的迷宫寻路系统
01-25
这是一个迷宫寻路小项目。 压缩包里有已经封装好的exe文件maze.exe，双击即可运行。 源代码也在压缩包中，直接用python运行maze.py即可（python版本3.6，要装pygame） 推荐一篇介绍A 算法的博文，解释的非常好：http://blog.csdn.net/hitwhylz/article/details/23089415 求好评！！！
java用A*算法简单做的迷宫
10-29
用java完成的，关于启发式搜索算法在迷宫问题中的求解。
A*算法解迷宫
03-18
C语言实现，用A*算法和深度优先算法实现了迷宫问题，界面设计非常不错，并且有两种搜索的比较。
A*算法搜索实现迷宫
10-29
A*算法是人工智能中的一种搜索算法，是一种启发式搜索算法，它不需遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。
基于A*算法的迷宫小游戏
m0_53095268的博客
12-16 1841
文章目录前言一、程序设计说明1.功能描述2.算法思想二、模块设计1.流程设计2.算法实现三、功能演示 前言 本文采用A*算法的思想，借助pycharm下的python环境，求解迷宫的最优路径问题。 一、程序设计说明 1.功能描述 2.算法思想 （1）A*算法介绍 A算法是一种启发式搜索算法。在A*算法中，从起点开始后，通过启发函数来检查相邻方格，找到代价最小的“节点”作为下一个“父节点”，不断地搜索直到找到最优解。 （2）open表和close表 A*算法的两个重要数据列表： ①open表：用来存储可.
实验三 基于A*算法的迷宫游戏
OJAC_hzx的博客
11-25 1186
一、实验目的 二、实验器材 三、实验内容 四、实验原理 五、实验步骤 六、实验具体过程 七、实验过程 八、实验结果分析
软件实习项目三：基于A*搜索算法迷宫游戏开发——代码
qq_50944418的博客
12-27 649
文章目录PMap.javaEMap.javaPaintMap.javaTest.javaAStarSolver.javaPoint.javaSolver.java PMap.java package gyt; import java.util.ArrayList; import javax.swing.JPanel; /**Prim算法： 让迷宫全都是墙。 选一个格，作为迷宫的通路，然后把它的邻墙放入列表。 当列表里还有墙时: 从列表里随机选一个墙，如果它对面的格子不
A*算法实现迷宫
m0_70919804的博客
03-02 2355
A*算法的使用
广度优先，dijkstra和A*的寻路走迷宫
jun7118的博客
03-18 513
广度优先算法： 四周扩散，每次步进一格，能找到起点到终点的最短路径。不能计算路径的cost。 dijkstra算法： 三个set，总set，已确定最小cost set，未确定最小cost set。 四周扩散，优先从未确定最小cost set中pop出到起点cost最小节点，加入已确定set，并更新此节点周围未确定最小cost的节点cost。 精髓在于每次迭代，都优先pop最小cost，保证已确定cost set节点一定能最小cost。 能计算每个点到起点的cost...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值