本文目录一览
- 1、C++设计一个迷宫并走出来
- 2、哪位前辈能够提供一段c++的走迷宫游戏的代码啊 叩谢了啊！！！！！！！！
- 3、C++课设 用room类和maze类实现的迷宫游戏 最多走八步
- 4、跪求老鼠走迷宫游戏，必须用C++编写，用栈来实现，因为是数据结构课程设计所以只要现成代码，越快越好。
- 5、求助用C或者C++语言实现一个迷宫小游戏代码
C++设计一个迷宫并走出来
本程序的前提是将迷宫保存在一个二维数组里，可走的地方为0，不可走的地方为1。由于采用回朔算法，不使用递归，所以首先应该建立一个栈来保存路径，路径是用一个一个点来表示的，也就是说栈中保存的是一系列点的列表。栈节点类型说明：
struct StackNode
{
POINT Point;
struct StackNode *Next, *Prev;//双向链表形式
};
栈结构用一个类（CPointStack）实现，声明如下：
class CPointStack
{
public:
void ClearStack();//清空栈
void InitStack();//初始化栈
bool Pop(POINT pt);//弹出顶端元素，并给出该点的坐标，返回是否弹出成功
bool Push(POINT pt);//将pt点的信息压入栈，返回是否压入成功
CPointStack();
virtual ~CPointStack();
protected:
StackNode *m_psnTop;//栈顶指针
StackNode m_snBottom;//栈底，不保存点信息
};
以下为成员函数实现，都是一些数据结构的操作，应该没什么好说的：
//构造时初始化栈
CPointStack::CPointStack()
{
InitStack();
}
//析构时清空栈
CPointStack::~CPointStack()
{
ClearStack();
}
//将点压入栈(成功返回true,失败返回false)
bool CPointStack::Push(POINT pt)
{
StackNode* NewNode = new StackNode;
//是否返回true主要看这里申请内存是否成功
if(!NewNode)
return false;
NewNode-Point = pt;
NewNode-Prev = m_psnTop;
NewNode-Next = NULL;
m_psnTop-Next = NewNode;
m_psnTop = NewNode;
return true;
}
//将点弹出栈(成功返回true,栈为空则返回false)
bool CPointStack::Pop(POINT pt)
{
if(m_psnTop == m_snBottom)//是否返回true主要看这里栈是否为空
return false;
StackNode *p;
p = m_psnTop;
m_psnTop = m_psnTop-Prev;
pt = p-Point;
delete p;
m_psnTop-Next = NULL;
return true;
}
//初始化栈
void CPointStack::InitStack()
{
m_psnTop = m_snBottom;
m_snBottom.Next = NULL;
m_snBottom.Prev = NULL;
}
//清空栈
void CPointStack::ClearStack()
{
StackNode *p;
while(m_psnTop != m_snBottom)
{
p = m_psnTop;
m_psnTop = m_psnTop-Prev;
delete p;
}
}
接下来设计怎样走出这个迷宫，也就是迷宫算法的主体部分。再次用一个类实现。
在设计这个类时，我考虑到以下几点：
1、迷宫入口和出口的坐标
2、保存迷宫的2维数组
3、获得路径的函数
但是实际设计时由于没有考虑太多问题，只是以设计迷宫算法和解决一个具体迷宫为目的，所以没有考虑动态大小的迷宫，而是将迷宫大小定为601×401。而且在设计迷宫算法后没有将路径顺序输出而是直接在原图中标识（在保存迷宫数据的表中设置经过的点为2而将死路点设置为3）。
这样迷宫类（CGoMaze）的声明为：
class CGoMaze
{
public:
void Go();//寻找路径的函数
POINT m_ptIn;//入口坐标
POINT m_ptOut;//出口坐标
BYTE m_btArrMaze[401][601];//保存迷宫的二维表
CGoMaze();
virtual ~CGoMaze();
};
最后让我们来看一下CGoMaze::Go()这个函数：
我们模仿人走迷宫时的思路，设置一个当前点，一个目标点（下一个要走的点）。初始情况下当前点为入口，终止条件为当前点为出口，这样，我们的函数大概结构就出来了。
在从入口到出口的过程中程序对当前点的上、下、左、右四个点依次进行判断，当发现任一个方向是未走过的区域时，就将当前点指向那个点进行尝试，同时将当前点入栈并做标记。而当4个方向都不通或已走过时，则为死路，标记当前点为死路并从栈中弹出上一个点继续进行尝试，这时因为当前点已被标记为死路，则弹出上一个点时就不会重复这条路，达到寻找正确路径的效果。
Go函数的具体实现如下，其实挺简单的^_^：
void CGoMaze::Go()
{
CPointStack psPath;//保存路径的栈
POINT ptCur = m_ptIn, ptNext;//设置当前点为入口
while(ptCur.x != m_ptOut.x || ptCur.y != m_ptOut.y)//判断是否已经走出
{
ptNext = ptCur;//设置目标点为当前点，便于下面偏移
if(m_btArrMaze[ptCur.y - 1][ptCur.x] == 0)
ptNext.y --;//如果上方是空的，则目标点向上偏移
else if(m_btArrMaze[ptCur.y][ptCur.x - 1] == 0)
ptNext.x --;//如果左边是空的，则目标点向左偏移
else if(m_btArrMaze[ptCur.y + 1][ptCur.x] == 0)
ptNext.y ++;//如果下方是空的，则目标点向下偏移
else if(m_btArrMaze[ptCur.y][ptCur.x + 1] == 0)
ptNext.x ++;//如果右边是空的，则目标点向右偏移
else
{//这里是没有路的状态
m_btArrMaze[ptCur.y][ptCur.x] = 3;//标记为死路
psPath.Pop(ptCur);//弹出上一次的点
continue;//继续循环
}
//如果有路的话会执行到这里
m_btArrMaze[ptCur.y][ptCur.x] = 2;//标记当前点为路径上的点
psPath.Push(ptCur);//当前点压入栈中
ptCur = ptNext;//移动当前点
}
}
其实这个部分可以将栈设置为CGoMaze类的成员，然后在Go函数里加上：
psPath.ClearStack();
这样就可以用Timer来演示走迷宫的过程了
哪位前辈能够提供一段c++的走迷宫游戏的代码啊 叩谢了啊！！！！！！！！
#include "graphics.h"#include "stdio.h"
#define N 10
#define M N*N-4+1 /*堆栈最大值，用来保存路口信息*/
#define UP 1
#define DOWN -1
#define LEFT 2
#define RIGHT -2
#define UP_M man.x-1=0a[man.x-1][man.y] /*人当前位置的上一个位置*/
#define DOWN_M man.x+1Na[man.x+1][man.y]
#define LEFT_M man.y-1=0a[man.x][man.y-1]
#define RIGHT_M man.y+1Na[man.x][man.y+1]
#define ENTER 3 /*岔路的入口*/
#define HAVE 2 /*某条路已经走过*/
struct cross{int up,down,left,right,x,y;} across,stack[M]={0};
int top=1;
int PX=70,PY=40;
struct {int x,y,s;}man;
/*迷宫定义，1表示路，可自行更改迷宫的路径，可使全为1，看效果等*/
int a[N][N]={0,0,0,1,1,0,1,1,1,0,
1,1,0,1,0,1,1,0,1,0,
0,1,1,1,1,0,1,1,1,1,
1,0,1,0,1,1,1,0,1,0,
1,1,1,1,0,0,1,1,1,1,
1,0,1,0,1,1,1,0,1,0,
0,0,1,1,1,0,1,1,1,0,
1,1,1,0,1,0,1,0,1,0,
0,0,1,0,1,1,1,0,1,1,
0,1,1,0,0,1,0,0,0,0};
void init_man() /*初始化人的状态，要求迷宫入口须在左侧*/
{int i;setcolor(WHITE);
for(i=0;iN;i++)
if(a[i][0]) {man.x=i;man.y=0;
if(a[i][1]) man.s=RIGHT;
else if(i+1Na[i+1][0]) man.s=DOWN;
else if(i-1=0a[i-1][0]) man.s=UP;
else {outtextxy(500,300,"no way!");getch();exit(0);}
return ;}
if(i==N) {outtextxy(500,300,"no enter!");getch();exit(0);}
}
void show_map() /*显示迷宫*/
{int i,j;
for(i=0;iN;i++)
for(j=0;jN;j++)
if(a[i][j]) {setfillstyle(1,WHITE);
bar(PX+j*20,PY+i*20,PX+j*20+20,PY+i*20+20);}
else {setfillstyle(1,LIGHTBLUE);
bar(PX+j*20,PY+i*20,PX+j*20+20,PY+i*20+20);}
setcolor(BLACK);
for(i=0;iN;i++)
{line(PX+i*20,PY,PX+i*20,PY+20*N);
line(PX,PY+i*20,PX+20*N,PY+i*20);}
}
void show_man(int color)
{
setfillstyle(1,color);
bar(PX+man.y*20+5,PY+man.x*20+5,PX+man.y*20+20-5,PY+man.x*20+20-5);
}
int cross() /*岔路判断*/
{int count=0;
if(UP_M) count++;
if(DOWN_M) count++;
if(LEFT_M) count++;
if(RIGHT_M) count++;
return count;}
void move() /*依据人的移动状态而移动到新位置*/
{
show_man(GREEN);
switch(man.s)
{case UP:man.x-=1;break;
case DOWN:man.x+=1;break;
case LEFT:man.y-=1;break;
case RIGHT:man.y+=1;break;
}
show_man(LIGHTRED);
}
void back() /*回头走*/
{switch(man.s)
{case UP:man.s=DOWN;move();break;
case DOWN:man.s=UP;move();break;
case LEFT:man.s=RIGHT;move();break;
case RIGHT:man.s=LEFT;move();break;
}
}
void go_on() /*为通路且不是岔路时，继续向前走*/
{switch(man.s)
{case UP:if(UP_M) move();
else if(LEFT_M) {man.s=LEFT;move();}
else if(RIGHT_M) {man.s=RIGHT;move();}
break;
case DOWN:if(DOWN_M) move();
else if(LEFT_M){man.s=LEFT;move();}
else if(RIGHT_M) {man.s=RIGHT;move();}
break;
case LEFT:if(LEFT_M) move();
else if(UP_M) {man.s=UP;move();}
else if(DOWN_M) {man.s=DOWN;move();}
break;
case RIGHT:if(RIGHT_M) move();
else if(UP_M) {man.s=UP;move();}
else if(DOWN_M) {man.s=DOWN;move();}
break;
}
}
int xin() /*判断人当前位置是否是新岔路口*/
{int i;
for(i=1;itop;i++)
if(man.x==stack[i].xman.y==stack[i].y) return i;
return 0;
}
void copy() /*拷贝岔路信息到across结构体*/
{across.x=man.x;
across.y=man.y;
if(UP_M==1) across.up=1;
else across.up=0;
if(DOWN_M==1) across.down=1;
else across.down=0;
if(LEFT_M==1) across.left=1;
else across.left=0;
if(RIGHT_M==1) across.right=1;
else across.right=0;
}
void rukou() /*为岔路设置一个入口*/
{switch(man.s)
{case UP:across.down=ENTER;break;
case DOWN:across.up=ENTER;break;
case LEFT:across.right=ENTER;break;
case RIGHT:across.left=ENTER;break;
}
}
void xuanlu(struct cross *p) /*在岔路时，为人选一条路行走*/
{switch(man.s)
{case UP:if(p-up==1) p-up=HAVE;
else if(p-left==1) {man.s=LEFT;p-left=HAVE;}
else if(p-right==1) {man.s=RIGHT;p-right=HAVE;}
else {man.s=DOWN;p-down=HAVE;}
break;
case DOWN:if(p-down==1) p-down=HAVE;
else if(p-left==1) {man.s=LEFT;p-left=HAVE;}
else if(p-right==1) {man.s=RIGHT;p-right=HAVE;}
else {man.s=UP;p-up=HAVE;}
break;
case LEFT:if(p-left==1) p-left=HAVE;
else if(p-up==1) {man.s=UP;p-up=HAVE;}
else if(p-down==1) {man.s=DOWN;p-down=HAVE;}
else {man.s=RIGHT;p-right=HAVE;}
break;
case RIGHT:if(p-right==1) p-right=HAVE;
else if(p-up==1) {man.s=UP;p-up=HAVE;}
else if(p-down==1) {man.s=DOWN;p-down=HAVE;}
else {man.s=LEFT;p-left=HAVE;}
break;
}
}
push(struct cross *p) /*把新岔路口入栈*/
{stack[top].left=p-left;
stack[top].right=p-right;
stack[top].up=p-up;
stack[top].down=p-down;
stack[top].x=p-x;
stack[top].y=p-y;
top++;
}
int wan(struct cross *p) /*当前人所在的岔路口走完否？*/
{int count=0;
if(p-left==1) count++;
if(p-right==1) count++;
if(p-up==1) count++;
if(p-down==1) count++;
if(count0) return 0;
return 1;
}
void chukou(struct cross *p) /*人从出口出来*/
{if(p-up==ENTER) man.s=UP;
else if(p-down==ENTER) man.s=DOWN;
else if(p-left==ENTER) man.s=LEFT;
else man.s=RIGHT;
}
main()
{int c,k;
int gdriver=DETECT,gmode;
registerbgidriver(EGAVGA_driver);
initgraph(gdriver,gmode,"");
cleardevice();
show_map();
init_man();show_man(LIGHTRED);getch();delay(65000);
do{
switch(c=cross())
{case 1:switch(man.s)
{case UP:if(UP_M) move();
else back();break;
case DOWN:if(DOWN_M) move();
else back();break;
case LEFT:if(LEFT_M) move();
else back();break;
case RIGHT:if(RIGHT_M) move();
else back();break;}
break;
case 2:go_on();break;
case 3:
case 4:k=xin();
if(!k) {copy();rukou();xuanlu(across);push(across);}
else {if(wan(stack[k])) chukou(stack[k]);
else xuanlu(stack[k]);}
move();
break;
}
delay(65000);
}while(!kbhit());
closegraph();}
==================================================
编译环境：tc 2.0
C++课设 用room类和maze类实现的迷宫游戏 最多走八步
书籍，称为结构（太多了），我做重叠！我希望你能帮助！程序如下：typedef结构{
诠释通道块编号;/ /路径条例
PosType的座椅;/ /通道块在迷宫中的坐标位置
二;/ /从通道块到下一个通道块方向
} SelemType ;/ /堆栈元素类型
状态MazePath（MazeType迷宫PosType的启动PosType结束）{
/ /迷宫迷宫开始从入口到出口端的通道，因此，寻求存储堆栈
/ /从堆栈的底部（顶部）和返回TRUE，否则返回FALSE
InitStack（S ）;
CURPOS =开始;/ /设置当前位置的入口位置
curstep = 1 ;/ /探索第一步
{
如果（通（CURPOS） ）{/ /当前位置可以，从来没有走过通道块
的足迹（CURPOS）;/ /留下脚印
é=（curstep CURPOS，1）;
推送（ E）;/ /路径
如果（CURPOS ==结束）
返回（TRUE）;/ /到达终点
CURPOS = nextpos（CURPOS，1）;/ /下一个位置当前位置东部
curstep + + ;/ /探索下一步
}
否则{/ /当前位置不能
（StackEmpty（S ））{
POP（S，E）;
（e.di == 4 ！StackEmpty（S））{
MarkPrint ;/（e.seat）/留下印记不能退一步
POP（S，E）;
}
（e.di 4）{
e.di + +;
推（ SE）;/ /换下一个方向探索 CURPOS = nextpos（e.seat e.di）;/ /设置当前位置的新方向相邻块
} / / /
} / /} / /其他
}（StackEmpty（S））;
回报（FALSE）;
} / / MazePath的
跪求老鼠走迷宫游戏，必须用C++编写，用栈来实现，因为是数据结构课程设计所以只要现成代码，越快越好。
#include "stdafx.h"
#include stack
using namespace std;
const int rows = 8,cols = 8;
HINSTANCE hInst;
HBITMAP ball;
HDC hdc,mdc,bufdc;
HWND hWnd;
DWORD tPre,tNow;
char *str;
int nowPos,prePos;
bool find;
stackint path;
int mapIndex[rows*cols] = { 0,2,0,0,0,0,0,0, ? //材1#59049;
0,1,0,1,1,1,1,0, ? //材2#59049;
0,1,0,1,0,1,1,0, ? //材3#59049;
0,1,0,0,0,1,1,0, ? //材4#59049;
0,1,1,1,1,1,1,0, ? //材5#59049;
0,1,0,0,0,0,1,0, ? //材6#59049;
0,0,1,1,1,1,1,0, ? //材7#59049;
0,0,0,0,0,0,3,0 }; //材8#59049;
int ?record[rows*cols];
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void MyPaint(HDC hdc);
int APIENTRY WinMain(HINSTANCE hInstance,
? ? ? ? ? ? ? ? ? ? ?HINSTANCE hPrevInstance,
? ? ? ? ? ? ? ? ? ? ?LPSTR ? ? lpCmdLine,
? ? ? ? ? ? ? ? ? ? ?int ? ? ? nCmdShow)
{
MSG msg;
MyRegisterClass(hInstance);
if (!InitInstance (hInstance, nCmdShow))?
{
return FALSE;
}
? ? while( msg.message!=WM_QUIT )
? ? {
? ? ? ? if( PeekMessage( msg, NULL, 0,0 ,PM_REMOVE) )
? ? ? ? {
? ? ? ? ? ? TranslateMessage( msg );
? ? ? ? ? ? DispatchMessage( msg );
? ? ? ? }
else
{
tNow = GetTickCount();
if(tNow-tPre = 100)
MyPaint(hdc);
}
? ? }
return msg.wParam;
}
//****注册窗口*************************
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);?
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = NULL;
wcex.hCursor = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = "canvas";
wcex.hIconSm = NULL;
return RegisterClassEx(wcex);
}
//****初始化*************************************
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HBITMAP bmp;
hInst = hInstance;
hWnd = CreateWindow("canvas", "迷宫" , WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
MoveWindow(hWnd,10,10,430,450,true);
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
hdc = GetDC(hWnd);
mdc = CreateCompatibleDC(hdc);
bufdc = CreateCompatibleDC(hdc);
bmp = CreateCompatibleBitmap(hdc,cols*50,rows*50);
SelectObject(mdc,bmp);
HBITMAP tile;
int rowNum,colNum;
int i,x,y;
tile = (HBITMAP)LoadImage(NULL,"tile.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE);
ball = (HBITMAP)LoadImage(NULL,"ball.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE);
for (i=0;irows*cols;i++)
{
record[i] = mapIndex[i];
rowNum = i / cols;
colNum = i % cols;
x = colNum * 50;
y = rowNum * 50;
SelectObject(bufdc,tile);
if(!mapIndex[i])
BitBlt(mdc,x,y,50,50,bufdc,0,0,SRCCOPY);
else
{
? if(mapIndex[i] == 2)
{
nowPos = i;
path.push(i);
record[i] = 0;
}
BitBlt(mdc,x,y,50,50,bufdc,0,0,WHITENESS);
}
}
prePos = cols * rows + 1;
MyPaint(hdc);
return TRUE;
}
//****核心代码*********************************
void MyPaint(HDC hdc)
{
int rowNum,colNum;
int x,y;
int up,down,left,right;
rowNum = prePos / cols;
colNum = prePos % cols;
x = colNum * 50;
y = rowNum * 50;
SelectObject(bufdc,ball);
BitBlt(mdc,x,y,50,50,bufdc,0,0, WHITENESS);
rowNum = nowPos / cols;
colNum = nowPos % cols;
x = colNum * 50;
y = rowNum * 50;
SelectObject(bufdc,ball);
BitBlt(mdc,x,y,50,50,bufdc,0,0, SRCCOPY);
if(!find)
{
str = "迷宫入口";
up ? ?= nowPos - cols;
down ?= nowPos + cols;
left ?= nowPos - 1;
right = nowPos + 1;
if(up=0 record[up])
{
path.push(up);
record[up] = 0;
prePos = nowPos;
nowPos = up;
? ? ? ? if(mapIndex[nowPos] == 3)
find = true;
}
else if(down=cols*rows-1 record[down])?
{
path.push(down);
record[down] = 0;
prePos = nowPos;
nowPos = down;
if(mapIndex[nowPos] == 3)
find = true;
}
else if(left=rowNum*cols record[left]) ?
{
path.push(left);
record[left] = 0;
prePos = nowPos;
nowPos = left;
if(mapIndex[nowPos] == 3)
find = true;
}
else if(right=(rowNum+1)*cols-1 record[right]) ?
{
path.push(right);
record[right] = 0;
prePos = nowPos;
nowPos = right;
if(mapIndex[nowPos] == 3)
find = true;
}
else
{
if(path.size() = 1) //#59076;#59343;#58864;#58892;
str = "xxxxx";
else
{
path.pop();
prePos = nowPos;
nowPos = path.top();
}
}
}
else
{
str = "找到出口";
}
TextOut(mdc,0,0,str,strlen(str));
BitBlt(hdc,10,10,cols*50,rows*50,mdc,0,0,SRCCOPY);
tPre = GetTickCount();
}
//****消息函数***********************************
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_KEYDOWN:
if(wParam==VK_ESCAPE)
PostQuitMessage(0);
break;
case WM_DESTROY:
DeleteDC(mdc);
DeleteDC(bufdc);
DeleteObject(ball);
ReleaseDC(hWnd,hdc);
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
? ?}
? ?return 0;
}
// ?可以运行 ? 请采纳 ??
有不懂的可以联系我
这个可是标准c++的 ? 这是结果
这是源代码?
求助用C或者C++语言实现一个迷宫小游戏代码
#includebits/stdc++.h
#includewindows.h
#includeconio.h
using namespace std;
int main()
{
int i123;
cout"? ?."endl;
cout"? . ."endl;
cout" . . ."endl;
cout"? . ."endl;
cout"? ?."endl;
cout"? T M";
for(i123=500;i123=1000;i123+=100){
Beep(i123,1000);
}
system("cls");
char a[50][50]={"##############################",
? ? ? ? "#o? ? ? ? ?#? ?##? ?# ### ####",
? ? ? ? "# ###### # # #? ? # # ### ####",
? ? ? ? "# #? ?## #? ?# #### # ###? ?##",
? ? ? ? "#? ?# ##? ###? ? #? #? ## ####",
? ? ? ? "##### #? ? ?# ##### ##? ? ####",
? ? ? ? "#? ?# ##### #? ?#? ?# # #? ? #",
? ? ? ? "# # #? ? ## # #### ## # # ####",
? ? ? ? "# # # ##? ? ? ##? ? ? # # ####",
? ? ? ? "# # # ####### ## ###### #? ?##",
? ? ? ? "# #? ?##? ?# ## ###### ###? ?#",
? ? ? ? "# ###### # #####? #? ? ? ? # #",
? ? ? ? "#? ? ? ? # #? ? ?##### ### #? ",
? ? ? ? "# ######## ##### # ### ### # #",
? ? ? ? "#? ? ?# ## ##### ###? ? ? ?###",
? ? ? ? "##### # ## #? ? ? ######## # #",
? ? ? ? "#? ? ?# ## ## ###? ? ? ? #? ?#",
? ? ? ? "# # ###? ? ? ?###### ####### #",
? ? ? ? "# #? ? ### ##? ? ? #? ? ? ? ?#",
? ? ? ? "##############################"
? ? ? ? };
int i,i1,x=1,y=1,n=12,m=29;
char ch;
for(i=0;i=19;i++){
puts(a[i]);
}
while(x!=n||y!=m){
? ch=getch();
if(ch==115||ch==25){
if(a[x+1][y]!=35){
a[x][y]=32;
x++;
a[x][y]=111;
}
}
if(ch==119||ch==24){
if(a[x-1][y]!=35){
a[x][y]=32;
x--;
a[x][y]=111;
}
}
if(ch==97||ch==27){
if(a[x][y-1]!=35){
a[x][y]=32;
y--;
a[x][y]=111;
}
}
if(ch==100||ch==26){
if(a[x][y+1]!=35){
a[x][y]=32;
y++;
a[x][y]=111;
}
}
system("cls");
for(i=0;i=19;i++){
puts(a[i]);
}
}
for(i1=500;i1=1000;i1=i1+100){
Beep(i1,1000);
}
coutendl"你赢了！！！祝贺你！！！";
system("pause");
}
- 随机文章
标签 c课设 用room类和maze类实现的迷宫游戏 最多走八步_c走迷宫游戏
