maze20080330_01.cpp

迷宫.控制台应用程序.适合出学c语言又想提高c语言的朋友

// Maze20080329_03.cpp : Defines the entry point for the console application.


#include "stdafx.h"
#include<windows.h>
 #include<conio.h>
#include <stdio.h> 
#include "stdlib.h"
#include "time.h"

//#include "StackExercise.cpp"
#include "StackExercise.h"
#include "main.h"
#include <iostream>
using namespace std;


bool bMazePathHelp = false;
//bool bMazePathHelp = true;
 
void main()
{
	GameMaze();
}
void GameMaze( void )
{
	srand(time(NULL));
	SMazeMap maze;
	MazeInit( &maze );
	CreateMaze( &maze );
	MazeShowInit( &maze );
 	cout<<"简要说明：一天 Peter 不小心闯进了一个迷宫，他被困在迷宫里了。"<<endl;
	cout<<"          缘分使他遇见了你，他想得到你的帮助，需要你为他指引方向。"<<endl;
	cout<<"    操作：你可以用键盘上的 w (上) 、s (下)、a (左)、 s (右) 为他指引。"<<endl;
	cout<<"    帮助：当然如果你也需要帮助的话，我们为你准备了地图，"<<endl;
	cout<<"          键盘上的 m (地图)"<<endl;
	cout<<"          按任意键进入迷宫..."<<endl;
	cout<<""<<endl;
	cout<<""<<endl;
 	while( !_kbhit() );
	clrscr ();
   	MazeShow( &maze );
	cout<<endl;
 	MazePathHelp( &maze );
  	ControlPersonOfMaze( &maze );
 

}
void FailExitMaze(void)
{
	cout<<endl <<endl;
	cout<<endl <<endl;
	cout<<endl <<endl;
	cout<<endl <<endl;
	cout<<endl<<"继续努力啊！"<<endl;
}
void SuccessExitMaze(void)
{
	cout<<endl <<endl;
	cout<<endl <<endl;
	cout<<endl <<endl;
	cout<<endl <<endl;
 	cout<<endl<<"恭喜你们成功的走出了迷宫"<<endl;
}
void ControlPersonOfMaze(SMazeMap *p)
{
	char chKey;


	HANDLE hCursor;
	SetConsoleTitle("迷宫--------------李元设计");
	COORD size = {300,500}; 
//	SetConsoleScreenBufferSize(hCursor,size); // 重新设置缓冲区大小 
 	SMALL_RECT rc = {0,0, 300-1, 500-1}; // 重置窗口位置和大小 	
	CloseHandle(hCursor);
	do
	{
		if( ExitMaze( p ) )
		{
			SuccessExitMaze();
			return;
		}
		while( !_kbhit() );

		 chKey = _getch();
		
		switch( chKey )
		{
		case Key_w:
		case Key_W:
			GoUp(p);
			break;
		case Key_s:
		case Key_S:
			GoDown(p);
			break;
		case Key_a:
		case Key_A:
			GoLeft(p);
			break;
		case Key_d:
		case Key_D:
			GoRight(p);
			break;
		case Key_p:
		case Key_P:
			if( bMazePathHelp )
			{
				bMazePathHelp = false;
			}
			else
			{
				bMazePathHelp = true;
			}
			break;
 		case Key_m:
		case Key_M:
		 	ClearShowMap();
			MazeHelp(p);
 			MazeShow(p);
			break;
		default:
			;
		}
	}while( chKey != 'q' );

	 FailExitMaze();

}
bool ExitMaze(SMazeMap *p)
{
	if( p->spEnd.iRow == p->spCurrent.iRow \
		&& p->spEnd.iCol == p->spCurrent.iCol )
	{
 		return true;
	}
	return false;
}
void GoUp(SMazeMap *p)
{
 	if( p->cMazeMap[p->spCurrent.iRow-1][p->spCurrent.iCol] != MAZE_BAR )
	{
		p->cMazeMap[p->spCurrent.iRow-1][p->spCurrent.iCol] = MAZE_PER;
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol] = MAZE_FOOTPRINT;
		p->spCurrent.iRow--;
		p->spShowCurrent.iRow--;											//在显示屏幕中的人的当前坐标上移
		if( p->spShowBegin.iRow > 0 )
		{
			 if( p->spShowCurrent.iRow <= ( (MAZE_ROW+1) - (SHOW_ROW-1) / 2 ) )
				{
				 	p->spShowBegin.iRow--;									//显示的原点上移
					p->spShowCurrent.iRow++;			
				 }
		}
		for(int i=0; i< SHOW_ROW; i++ )
		{
			for(int j=0; j< SHOW_COL; j++ )
			{
				p->cShowMazeMap[i][j] = p->cMazeMap[p->spShowBegin.iRow+i][p->spShowBegin.iCol+j];
			}
		}
		MazeShow( p );

	}
}
void GoDown(SMazeMap *p)
{
 	if( p->cMazeMap[p->spCurrent.iRow+1][p->spCurrent.iCol] != MAZE_BAR )
	{
		p->cMazeMap[p->spCurrent.iRow+1][p->spCurrent.iCol] = MAZE_PER;
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol] = MAZE_FOOTPRINT;
		p->spCurrent.iRow++;
		p->spShowCurrent.iRow++;
		if( p->spShowBegin.iRow < (MAZE_ROW+1) - (SHOW_ROW-1)  )
		{
			 if( p->spShowCurrent.iRow >= (MAZE_ROW+1) - (SHOW_ROW-1) / 2 )
				{
					p->spShowBegin.iRow++;
					p->spShowCurrent.iRow--;
				 }
		}
		for(int i=0; i< SHOW_ROW; i++ )
		{
			for(int j=0; j< SHOW_COL; j++ )
			{
				p->cShowMazeMap[i][j] = p->cMazeMap[p->spShowBegin.iRow+i][p->spShowBegin.iCol+j];
			}
		}
		MazeShow( p );
	}
}
void GoLeft(SMazeMap *p)
{
 	if( p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol-1] != MAZE_BAR )
	{
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol] = MAZE_FOOTPRINT;
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol-1] = MAZE_PER;
		p->spCurrent.iCol--;
		p->spShowCurrent.iCol--;
		if( p->spShowBegin.iCol > 0 )
		{
			 if( p->spShowCurrent.iCol <= ( (MAZE_COL+1) - (SHOW_COL-1) / 2 )  )
				{
					p->spShowBegin.iCol--;
					p->spShowCurrent.iCol++;
				}
		}
		for(int i=0; i< SHOW_ROW; i++ )
		{
			for(int j=0; j< SHOW_COL; j++ )
			{
				p->cShowMazeMap[i][j] = p->cMazeMap[p->spShowBegin.iRow+i][p->spShowBegin.iCol+j];
			}
		}
		MazeShow( p );
	}
}
void GoRight(SMazeMap *p)
{
 	if( p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol+1] != MAZE_BAR )
	{
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol+1] = MAZE_PER;
		p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol] = MAZE_FOOTPRINT;
		p->spCurrent.iCol++;
		p->spShowCurrent.iCol++;
		if( p->spShowBegin.iCol < (MAZE_COL+1)-(SHOW_COL-1) )
		{
			 if( p->spShowCurrent.iCol >= ( (SHOW_COL+1) - (SHOW_COL-1) / 2 ) )
				{
					p->spShowBegin.iCol++;
					p->spShowCurrent.iCol--;
				}
		}
		for(int i=0; i< SHOW_ROW; i++ )
		{
			for(int j=0; j< SHOW_COL; j++ )
			{
				p->cShowMazeMap[i][j] = p->cMazeMap[p->spShowBegin.iRow+i][p->spShowBegin.iCol+j];
			}
		}
		MazeShow( p );
	}
}

void CreateMaze(SMazeMap *p)
{

	p->cMazeMap[p->spCurrent.iRow][p->spCurrent.iCol] = MAZE_PER;
	p->cMazeMap[p->spEnd.iRow][p->spEnd.iCol] = MAZE_EXIT;



}
void MazeInit( SMazeMap *p )
{
	MazeFullInit( p );
	MazeInitPath( p );
}
void MazeShowInit(SMazeMap *p)
{
	p->spShowBegin.iRow = (MAZE_ROW+1)-(SHOW_ROW-1);
	p->spShowBegin.iCol = (MAZE_COL+1)-(SHOW_COL-1);

	p->spShowCurrent.iRow = p->spCurrent.iRow;
	p->spShowCurrent.iCol = p->spCurrent.iCol;
	for(int i=0; i< SHOW_ROW; i++ )
	{
		for(int j=0; j< SHOW_COL; j++ )
		{
			p->cShowMazeMap[i][j] = p->cMazeMap[p->spShowBegin.iRow+i][p->spShowBegin.iCol+j];
		}
		cout<<endl;
	}
}
void SetMazeEnterAndExit(SMazeMap *p)
{
 /*	p->cMazeMap[1][1] = MAZE_PATH;
 	p->cMazeMap[1][MAZE_COL] = MAZE_PATH;
 	p->cMazeMap[MAZE_ROW][1] = MAZE_PATH;
 	p->cMazeMap[MAZE_ROW][MAZE_COL] = MAZE_PATH;*/

	//设定出口
	int iRandomNumber;
	iRandomNumber =  rand()%3;
	switch( iRandomNumber )
	{
	case 0:
		p->spEnd.iRow = 1;				//左上角
		p->spEnd.iCol = 0;
		break;
	case 1:
		p->spEnd.iRow = MAZE_ROW;		//左下角
		p->spEnd.iCol = 0;
		break;
	case 2:
		p->spEnd.iRow = 1;				//右上角
		p->spEnd.iCol = MAZE_COL+1;
		break;
	}
	p->cMazeMap[p->spEnd.iRow][p->spEnd.iCol] = MAZE_PATH_1;

	//设定入口，右下角						
	p->spBegin.iRow = MAZE_ROW;
	p->spBegin.iCol = MAZE_COL;
	p->spCurrent.iRow = MAZE_ROW;
	p->spCurrent.iCol = MAZE_COL;

}
void MazeInitPath(SMazeMap *p)
{
	SetMazeEnterAndExit( p );
	SPos posEnter;					//入口点
	SPos posExit;					//出口点
  	posEnter.iRow = MAZE_ROW;
	posEnter.iCol = MAZE_COL;
	posExit.iRow = p->spEnd.iRow;
	posExit.iCol = p->spEnd.iCol;

	if( posExit.iRow == MAZE_ROW )
	{
		posExit.iCol++;
	}
	else if ( posExit.iCol == 0 )
	{
		posExit.iCol++;
	}
	else
	{
		posExit.iCol--;
	}
	p->cMazeMap[posExit.iRow][posExit.iCol] = MAZE_PATH_1;
 	while( p->cMazeMap[posEnter.iRow][posEnter.iCol] != MAZE_PATH_1 && p->cMazeMap[posExit.iRow][posExit.iCol] != MAZE_PATH )
	{ 
		DigPath( p, &posEnter, MAZE_PATH );					//从入口点开始挖
 	 	DigPath( p, &posExit, MAZE_PATH_1 );				//从出口点开始挖
	}
 
	OptimizeMazePath( p );
 	
}
void OptimizeMazePath(SMazeMap *p)
{
	//优化迷宫
	SPos sPos;
 	int iCount=10;
	char cOptimizeMazePathFlag = OPTIMIZE_MAZE_PATH;
 	for( int i=1; i<= MAZE_ROW; i++ )
	{
		for( int j=1; j<= MAZE_COL; j++ )
		{
			if( p->cMazeMap[i-1][j] == MAZE_BAR \
				&& p->cMazeMap[i+1][j] == MAZE_BAR \
			 	&& p->cMazeMap[i][j-1] == MAZE_BAR \
				&& p->cMazeMap[i][j+1] == MAZE_BAR  )
			{
				sPos.iRow = i;
				sPos.iCol = j;
			 	iCount = 10*MAZE_COL;
				p->cMazeMap[sPos.iRow][sPos.iCol] = cOptimizeMazePathFlag;
  			//	while( p->cMazeMap[sPos.iRow][sPos.iCol] != MAZE_PATH_1 && p->cMazeMap[sPos.iRow][sPos.iCol] != MAZE_PATH )
  				while( iCount -- )
				{ 
			 		OptimizeDigPath( p, &sPos, OPTIMIZE_MAZE_PATH );			//从地图中没有被挖过的地方开始挖到已经挖好的地方
				}
			}

		}
	} 
}
bool OptimizeDigging(SMazeMap *p,SPos *pPos,char cOptimizeMazePathFlag, int iDir )
{
  	if( iDir == DIR_LEFT )
	{//如果方向向左,检查上,下和左是否都没有被挖过
		pPos->iCol--;
		if( pPos->iCol < 1 )
		{//遇到墙壁不能挖
			pPos->iCol++;
			return false;
		}
   		else if( p->cMazeMap[pPos->iRow][pPos->iCol] != MAZE_BAR \
				&& p->cMazeMap[pPos->iRow][pPos->iCol] != cOptimizeMazePathFlag )
		{//该点的前一点已经被别人挖过,挖了该点并跳到右一点,此时走过去会合
   			return false;
 		}
		else if( ( p->cMazeMap[pPos->iRow-1][pPos->iCol] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow+1][pPos->iCol] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow][pPos->iCol-1] == MAZE_BAR ) )
		{//周围都没有被挖过,挖
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
			return true;
		}
  		else if( p->cMazeMap[pPos->iRow-1][pPos->iCol] == MAZE_BAR \
				&& p->cMazeMap[pPos->iRow+1][pPos->iCol] == MAZE_BAR )
		{//该点的上下没有被别人挖过,挖了该点 
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
   			return true;
 		}
		else if( p->cMazeMap[pPos->iRow][pPos->iCol] == cOptimizeMazePathFlag )
		{//该点前一点  已经被自己挖过,走过去
  			return false;
		}
  		else
		{
 			pPos->iCol++;
 			return false;
		}
	}
	if( iDir == DIR_RIGHT )
	{
		pPos->iCol++;
		if( pPos->iCol > MAZE_COL )
		{//遇到墙壁不能挖
			pPos->iCol--;
			return false;
		}
 		else if( p->cMazeMap[pPos->iRow][pPos->iCol] != MAZE_BAR \
				&& p->cMazeMap[pPos->iRow][pPos->iCol] != cOptimizeMazePathFlag )
		{//会合
   			return false;
 		}
		else if( p->cMazeMap[pPos->iRow][pPos->iCol] == cOptimizeMazePathFlag )
		{//已经被自己挖过,走过去
  			return false;
		}
		else if( ( p->cMazeMap[pPos->iRow-1][pPos->iCol] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow+1][pPos->iCol] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow][pPos->iCol+1] == MAZE_BAR ) )
		{
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
			return true;
		}
 		else if( p->cMazeMap[pPos->iRow-1][pPos->iCol] == MAZE_BAR \
				&& p->cMazeMap[pPos->iRow+1][pPos->iCol] == MAZE_BAR )
		{ 
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
    		return true;
 		}
		else
		{
 			pPos->iCol--;
			return false;
		}
	}
	if( iDir == DIR_UP )
	{
		pPos->iRow--;
		if( pPos->iRow < 1  || pPos->iCol < 1 || pPos->iCol > MAZE_COL )
		{//遇到墙壁不能挖
			pPos->iRow++;
			return false;
		}
 		else if( p->cMazeMap[pPos->iRow-1][pPos->iCol] != MAZE_BAR \
				&& p->cMazeMap[pPos->iRow-1][pPos->iCol] != cOptimizeMazePathFlag )
		{// 会合
    			return false;
 		}
		else if( p->cMazeMap[pPos->iRow][pPos->iCol] == cOptimizeMazePathFlag )
		{//该点已经被自己挖过,走去
  			return false;
		}
		else if( ( p->cMazeMap[pPos->iRow][pPos->iCol-1] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow][pPos->iCol+1] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow-1][pPos->iCol] == MAZE_BAR ) )
		{
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
			return true;
		}
   		else if( p->cMazeMap[pPos->iRow][pPos->iCol-1] == MAZE_BAR \
				&& p->cMazeMap[pPos->iRow][pPos->iCol+1] == MAZE_BAR )
		{//该点的左右没有被别人挖过,挖了该点 
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
   			return true;
 		}
 		else
		{
 			pPos->iRow++;
 			return false;
		}
	}
	if( iDir == DIR_DOWN )
	{
		pPos->iRow++;
		if( pPos->iRow > MAZE_ROW  || pPos->iCol < 1 || pPos->iCol > MAZE_COL )
		{//遇到墙壁不能挖
			pPos->iRow--;
			return false;
		}
 		else if( p->cMazeMap[pPos->iRow][pPos->iCol] != MAZE_BAR \
				&& p->cMazeMap[pPos->iRow][pPos->iCol] != cOptimizeMazePathFlag )
		{// 会合
  			return false;
 		}
		else if( p->cMazeMap[pPos->iRow][pPos->iCol] == cOptimizeMazePathFlag )
		{//该点已经被自己挖过
  			return false;
		}
		else if( ( p->cMazeMap[pPos->iRow][pPos->iCol-1] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow][pPos->iCol+1] == MAZE_BAR )\
			&&( p->cMazeMap[pPos->iRow+1][pPos->iCol] == MAZE_BAR ) )
		{
			p->cMazeMap[pPos->iRow][pPos->iCol] = cOptimizeMazePathFlag;//插入被挖过的标记
			return true;
		}