Ⅰ VB编写游戏时要如何写迷宫的脚本
游戏是自己写的，脚本当然也是自己设计定义的，没有什么标准
Ⅱ 洛奇英雄传什么是脚本
脚本就是副本，也指某些自动执行某样操作的程序，游戏里称非主线念轿副本叫脚本，那个科技应该有重置地图的功能，在迷宫昌谈40层杀完BOSS用耐高碰重置地图功能就能起到卡精验的效果，卡的时间越长精验越多
Ⅲ 用C语言编个走迷宫程序，要求：1：迷宫的规模和地图由程序随机自动生成。入口和出口由用户指定。
程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
用户名：migong
----------------------------------------------------------------------------------
/**//*
MazePath Demo BY Turbo C 2.0
Copyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
#define Space 0x20
#define Up 0x48
#define Down 0x50
#define Left 0x4b
#define Right 0x4d
#define Enter 0x0d
#define F2 0x3c
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
typedef struct {
int x;
int y;
} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
int foot;
int mark;
} MazeType;
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} Stack;
int Maze[20][30];
MazeType maze[20][30];
PosType StartPlace;
PosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
void CreatMaze(void);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
void Error(char *message);
Status InitStack(Stack *s);
Status DestroyStack(Stack *s);
Status ClearStack(Stack *s);
Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
SElemType Pop(Stack *s,SElemType e);
Status GetTop(Stack *s,SElemType *e);
Status StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
void MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/**//* Form the maze. */
{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
int x,y;
char c;
char savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
clrscr();
printf("Menu:\n\n");
printf("1.Load Mazefile:(*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
do
{
c=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
}
while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&&c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
{
printf("\n\nLoadName: ");
scanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
}
else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
printf("\nInput Length :\n");
scanf("%d",&m);
printf("\nInput Width :\n");
scanf("%d",&n);
if(m<4||n<4) Error("Input");
if(m>30||n>20) Error("Maze too large");
for(i=0;i<30;i++)
for(j=0;j<20;j++)
Maze[j][i]=2;
StartPlace.x=0;
StartPlace.y=0;
EndPlace.x=0;
EndPlace.y=0;
clrscr();
printf("\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf(" #");
Maze[i-1][j-1]=0;
}
printf("\n");
}
}
gotoxy(65,5);
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
printf("Start:Home");
gotoxy(65,9);
printf("End:End");
gotoxy(65,11);
printf("Delete Wall:Del");
gotoxy(65,13);
printf("Enter Wall:Enter");
gotoxy(65,15);
printf("Save Maze:F2");
gotoxy(65,17);
printf("Complete:F9");
gotoxy(65,19);
printf("Exit:Esc");
gotoxy(4,3);
x=4;y=3;
do
{
c=getch();
switch(c)
{
case Up: if(y>3) { y--; gotoxy(x,y); }
break;
case Down: if(y<n) { y++; gotoxy(x,y); }
break;
case Left: if(x>4) { x-=2; gotoxy(x,y); }
break;
case Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }
break;
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
break;
case Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
break;
case Home: if(Maze[y-2][x/2-1]&&!b_start)
{
StartPlace.x=x/2-1;
StartPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_start=TRUE;
}
break;
case End: if(Maze[y-2][x/2-1]&&!b_end)
{
EndPlace.x=x/2-1;
EndPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_end=TRUE;
}
break;
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
case F9: if(b_start&&b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
printf("Savename:");
scanf("%s",savename);
gotoxy(2,22);
if(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
gotoxy(2,22);
printf(" ");
gotoxy(x,y);
break;
default: break;
}
}
while(!flag);
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].mark=0;
maze[j][i].foot=0;
}
}
Status LoadMaze(char *file)
/**//* The maze has been loaded. */
{
FILE *fp;
char *buffer;
char ch;
int i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
return ERROR;
buffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
while(ch!=EOF)
{
buffer[i]=ch;
i++;
ch=fgetc(fp);
}
m=30;n=20;
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
if(buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }
if(k==0&&buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }
switch(buffer[i])
{
case ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;
StartPlace.x=k;
StartPlace.y=j;
b_start=TRUE;
break;
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
EndPlace.x=k;
EndPlace.y=j;
b_end=TRUE;
break;
default : break;
}
}
fclose(fp);
clrscr();
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].foot=0;
maze[j][i].mark=0;
if(Maze[j][i]==0)
{
gotoxy(2*i+2,j+2);
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
}
gotoxy(2*StartPlace.x+2,StartPlace.y+2);
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(2*EndPlace.x+2,EndPlace.y+2);
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
return OK;
}
Status SaveMaze(char *filename)
/**//* The maze has been saved. */
{
FILE *fp;
char *buffer;
int i,j,k;
fp=fopen(filename,"wb");
buffer=(char *)malloc(600*sizeof(char));
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
switch(Maze[j][k])
{
case 0: buffer[i]=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
case 1: buffer[i]=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
case 2: buffer[i]=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
default : Error("Write"); break;
}
if(k==StartPlace.x&&j==StartPlace.y) buffer[i]=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
if(k==EndPlace.x&&j==EndPlace.y) buffer[i]=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
fwrite(buffer,600,1,fp);
free(buffer);
fclose(fp);
return OK;
}
void Error(char *message)
{
clrscr();
fprintf(stderr,"Error:%s\n",message);
exit(1);
} /**//* Error */
Status InitStack(Stack *s)
/**//* The stack s has been created and is initialized to be empty. */
{
s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /**//* InitStack */
Status DestroyStack(Stack *s)
/**//* The stack s has been destroyed. */
{
s->top=NULL;
s->stacksize=0;
free(s->base);
s->base=NULL;
return OK;
} /**//* DestroyStack */
Status ClearStack(Stack *s)
/**//* The stack has been clear to be maximum. */
{
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /**//* ClearStack */
Boolean StackEmpty(Stack *s)
/**//* Check if the stack s is empty. */
{
if(s->top==s->base) return TRUE;
else return FALSE;
} /**//* StackEmpty */
int StackLength(Stack *s)
/**//* Gain the length of the stack s. */
{
if(s->top>s->base) return (int)(s->top-s->base);
else return 0;
} /**//* StackLength */
Status Push(Stack *s,SElemType e)
/**//* The element e has been pushed into the stack s. */
{
if(s->top-s->base>=s->stacksize)
{
s->base=(SElemType *)realloc(s->base,
(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base+s->stacksize;
s->stacksize+=STACKINCREMENT;
}
*s->top++=e;
return OK;
} /**//* Push */
SElemType Pop(Stack *s,SElemType e)
/**//* The element e has been removed from the stack s. */
{
if(s->top==s->base) Error("Pop");
e=*--s->top;
return e;
} /**//* Pop */
Status GetTop(Stack *s,SElemType *e)
/**//* The element e has got to the top of the stack s.*/
{
if(s->top==s->base) Error("GetTop");
*e=*(s->top-1);
return OK;
} /**//* GetTop */
/**//* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
/**//* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
{
SElemType p;
int result;
if(s->top==s->base) return ERROR;
p=s->base;
while(!(p==s->top))
{
result=(*visit)(p);
p++;
}
return OK;
} */
Boolean Pass(PosType curpos)
/**//* Check if the current position can be passed. */
{
if(maze[curpos.x][curpos.y].td==1&&
maze[curpos.x][curpos.y].foot==0&&maze[curpos.x][curpos.y].mark==0)
return TRUE;
else return FALSE;
} /**//* Pass */
void MarkPrint(PosType seat)
/**//* Mark the position seat. */
{
maze[seat.x][seat.y].mark=-1;
/**//* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
} /**//* MarkPrint */
void FootPrint(PosType curpos)
/**//* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
{
maze[curpos.x][curpos.y].foot=1;
} /**//* FootPrint */
PosType NextPos(PosType seat,int di)
{
switch(di)
{
case 1: seat.y++; return seat; /**//* Eastward */
case 2: seat.x++; return seat; /**//* Southward */
case 3: seat.y--; return seat; /**//* Westward */
case 4: seat.x--; return seat; /**//* Northward */
default: seat.x=0; seat.y=0; return seat;
}
} /**//* NextPos */
/**//* The key to the program. */
/**//* Pre: The maze array & the startplace & the endplace.
Post: Find the one traverse of the maze and perform the mazepath.
Uses: The ADT stack class.
*/
Status MazePath(PosType start,PosType end)
{
PosType curpos;
int curstep;
SElemType e;
Stack *s,stack;
stack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!stack.base) Error("Overflow");
stack.top=stack.base;
stack.stacksize=STACK_INIT_SIZE;
s=&stack;
curpos=start;
curstep=1;
do
{
if(Pass(curpos))
{
FootPrint(curpos);
e.ord=curstep; e.seat=curpos; e.di=1;
gotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /**//* pospone time. */
Push(s,e);
if(curpos.x==end.x&&curpos.y==end.y) /**//* Proceed recursively. */
{
DestroyStack(s);
return TRUE;
}
curpos=NextPos(curpos,1); /**//* Try next position. */
curstep++;
}
else
{
if(!StackEmpty(s))
{
e=Pop(s,e); /**//* Removed e from s. */
while(e.di==4&&!StackEmpty(s)) /**//* Four directions have been checked
and s is not empty. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /**//* Pospone time. */
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
e=Pop(s,e); /**//* Remove e from s. */
curstep--;
}
if(e.di<4) /**//* The current position hasnot been checked. */
{
e.di++;
Push(s,e); /**//* Insert e into s. */
curpos=NextPos(e.seat,e.di); /**//* Try next position. */
}
}
}
}
while(!StackEmpty(s));
DestroyStack(s);
return FALSE;
} /**//* MazePath */
void main()
{
PosType start,end;
CreatMaze();
start.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
if(MazePath(start,end))
{
gotoxy(2,22);
printf("Path found\n");
}
else
{
gotoxy(2,22);
printf("Path not found\n");
}
getch();
clrscr();
}
Ⅳ C++ 最简单的迷宫
这里给你提供2个程序
1.用栈实现迷宫问题求解
2.老鼠走迷宫程序实例
1.用栈实现迷宫问题求解
源程序：
//base.h
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
//stack.h
#include "base.h"
#define INIT_SIZE 100 //存储空间初始分配量
#define INCREMENT 10 //存储空间兆岩分配增量
typedef struct{ //迷宫中r行c列的位置
int r;
int c;
}PostType;
typedef struct{
int ord; //当前位置在路径上的序号
PostType seat;//当前坐标
int di; //往下一坐标的方向
}SElemType; //栈元素类型
typedef struct{
SElemType* base;//栈基址,构造前销毁后为空
SElemType* top;//栈顶
int stackSize; //栈容量
}Stack; /租猜败/栈类型
Status InitStack(Stack &S){ //构造空栈s
S.base=(SElemType*)malloc(INIT_SIZE *sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);//存储分配失败
S.top=S.base;
S.stackSize=INIT_SIZE;
return OK;
}//InitStack
Status StackEmpty(Stack S){
//若s为空返回TRUE,否则返回FALSE
if(S.top==S.base)
return TRUE;
return FALSE;
}//StackEmpty
Status Push(Stack &S,SElemType e){
//插入元素e为新的弊颤栈顶元素
if(S.top-S.base >=S.stackSize){//栈满，加空间
S.base=(SElemType *)realloc(S.base,(S.stackSize+INCREMENT)*sizeof(SElemType));
if(!S.base)
exit(OVERFLOW); //存储分配失败
S.top=S.base+S.stackSize;
S.stackSize+=INCREMENT;
}
*S.top++=e;
return OK;
}//push
Status Pop(Stack &S,SElemType &e){//若栈不空删除栈//顶元素用e返回并返回OK，否则返回ERROR
if(S.top==S.base)
return ERROR;
e=*--S.top;
return OK;
}//Pop
Status DestroyStack(Stack &S){//销毁栈S,
free(S.base);
S.top=S.base;
return OK;
}//DestroyStack
//maze.cpp
#include "stack.h"
#define MAXLEN 10//迷宫包括外墙最大行列数目
typedef struct{
int r;
int c;
char adr[MAXLEN][MAXLEN];//可取’ ’’*’ ’@’ ’#’
}MazeType; //迷宫类型
Status InitMaze(MazeType &maze){
//初始化迷宫若成功返回TRUE,否则返回FALSE
int m,n,i,j;
printf("Enter row and column numbers: ");
scanf("%d%d",&maze.r,&maze.c); //迷宫行和列数
for(i=0;i<=maze.c+1;i++){//迷宫行外墙
maze.adr[0][i]=’#’;
maze.adr[maze.r+1][i]=’#’;
}//for
for(i=0;i<=maze.r+1;i++){//迷宫列外墙
maze.adr[i][0]=’#’;
maze.adr[i][maze.c+1]=’#’;
}
for(i=1;i<=maze.r;i++)
for(j=1;j<=maze.c;j++)
maze.adr[i][j]=’ ’;//初始化迷宫
printf("Enter block’s coordinate((-1,-1) to end): ");
scanf("%d%d",&m,&n);//接收障碍的坐标
while(m!=-1){
if(m>maze.r || n>maze.c)//越界
exit(ERROR);
maze.adr[m][n]=’#’;//迷宫障碍用’#’标记
printf("Enter block’s coordinate((-1,-1) to end): ");
scanf("%d%d",&m,&n);
}//while
return OK;
}//InitMaze
Status Pass(MazeType maze,PostType curpos){
//当前位置可通则返回TURE,否则返回FALSE
if(maze.adr[curpos.r][curpos.c]==’ ’)//可通
return TRUE;
else
return FALSE;
}//Pass
Status FootPrint(MazeType &maze,PostType curpos){
//若走过并且可通返回TRUE,否则返回FALSE
//在返回之前销毁栈S
maze.adr[curpos.r][curpos.c]=’*’;//"*"表示可通
return OK;
}//FootPrint
PostType NextPos(PostType &curpos,int i){
//指示并返回下一位置的坐标
PostType cpos;
cpos=curpos;
switch(i){ //1.2.3.4分别表示东,南,西,北方向
case 1 : cpos.c+=1; break;
case 2 : cpos.r+=1; break;
case 3 : cpos.c-=1; break;
case 4 : cpos.r-=1; break;
default: exit(ERROR);
}
return cpos;
}//Nextpos
Status MarkPrint(MazeType &maze,PostType curpos){
//曾走过但不是通路标记并返回OK
maze.adr[curpos.r][curpos.c]=’@’;//"@"表示曾走过但不通
return OK;
}//MarkPrint
Status MazePath(MazeType &maze,PostType start,PostType end){
//若迷宫maze存在从入口start到end的通道则求得一条存放在栈中
//并返回TRUE,否则返回FALSE
Stack S;
PostType curpos;
int curstep;//当前序号,1.2.3.4分别表示东,南,西,北方向
SElemType e;
InitStack(S);
curpos=start; //设置"当前位置"为"入口位置"
curstep=1; //探索第一步
do{
if(Pass(maze,curpos)){//当前位置可以通过,
//即是未曾走到过的通道
FootPrint(maze,curpos);//留下足迹
e.ord=curstep;
e.seat=curpos;
e.di=1;
Push(S,e); //加入路径
if(curpos.r==end.r&& curpos.c==end.c)
if(!DestroyStack(S))//销毁失败
exit(OVERFLOW);
else
return TRUE; //到达出口
else{
curpos=NextPos(curpos,1);
//下一位置是当前位置的东邻
curstep++; //探索下一步
}//else
}//if
else{ //当前位置不通
if(!StackEmpty(S)){
Pop(S,e);
while(e.di==4
&& !StackEmpty(S)){
MarkPrint(maze,e.seat);
Pop(S,e);
//留下不能通过的标记,并退一步
}//while
if(e.di < 4){
e.di++;//换下一个方向探索
Push(S,e);
curpos=NextPos(e.seat,e.di);//设定当前位置是该
//新方向上的相邻
}//if
}//if
}//else
}while(!StackEmpty(S));
if(!DestroyStack(S))//销毁失败
exit(OVERFLOW);
else
return FALSE;
}//MazePath
void PrintMaze(MazeType &maze){
//将标记路径信息的迷宫输出到终端(包括外墙)
int i,j;
printf("\nShow maze path(*---pathway):\n\n");
printf(" ");
for(i=0;i<=maze.r+1;i++)//打印列数名
printf("%4d",i);
printf("\n\n");
for(i=0;i<=maze.r+1;i++){
printf("%2d",i);//打印行名
for(j=0;j<=maze.c+1;j++)
printf("%4c",maze.adr[i][j]);//输出迷宫//当前位置的标记
printf("\n\n");
}
}//PrintMaze
void main(){ //主函数
MazeType maze;
PostType start,end;
char cmd;
do{
printf("-------FOUND A MAZEPATH--------\n");
if(!InitMaze(maze)){ //初始化并创建迷宫
printf("\nInitialization errors!!!\n");
exit(OVERFLOW); //初始化错误
}
do{ //输入迷宫入口坐标
printf("\nEnter entrance coordinate of the maze: ");
scanf("%d%d",&start.r,&start.c);
if(start.r>maze.r || start.c>maze.c){
printf("\nBeyond the maze!!!\n");
continue;
}
}while(start.r>maze.r || start.c>maze.c);
do{ //输入迷宫出口坐标
printf("\nEnter exit coordinate of the maze: ");
scanf("%d%d",&end.r,&end.c);
if(end.r>maze.r || end.c>maze.c){
printf("\nBeyond the maze!!!\n");
continue;
}
}while(end.r>maze.r || end.c>maze.c);
if(!MazePath(maze,start,end))//迷宫求解
printf("\nNo path from entrance to exit!\n");
else
PrintMaze(maze);//打印路径
printf("\nContinue?(y/n): ");
scanf("%s",&cmd);
}while(cmd==’y’ || cmd==’Y’);
}//main
2.老鼠走迷宫程序实例
#include "stdafx.h"
#include "iostream.h"
#include "string.h"
#include "stdio.h"
double dMeans=0,dWalkLen=10000;//dMeans表示走出迷宫的方法，dWalkLen表示当前走出迷宫最少步数
char Maze[10][52]={
{"###################################################"},
{"% ## #### ### ### # ####"},
{"# ## # ### ### ###### ### ############ # # #"},
{"# ## ## ### ## ## # # ## # # ####"},
{"# # # ## ## ### # # ######### # # # ##"},
{"# # # # ## ########## #### ## # #"},
{"# ## ### ## ## ### #### ## ## # # ######### #"},
{"# # # ## ## # ## #### # # ## ####"},
{"#### ## #### #### ## # ### ## ## @"},
{"###################################################"},
}; //迷宫
int MazeFlag[10][51]; //迷宫的标志：0表示未走过，i(i=1,2,3,4)表示已经走过了,i表示方向。
int MazeMin[10][51]; //路径最小的迷宫的标志
void Walk(int nx,int ny);//走迷宫的函数，nx是列，ny是行
void PrintOut(); //打印路径及迷宫的函数，同时比较获取路径较短的行走方法
int Judge(int nx,int ny,int i);//判断在第nx列ny行向第i个方向走是否可以,可以返回1否则返回0。
//i=1表示向右，2表示向下，3表示向左，4表示向上
/*---------------------------------------------------------------------------------------------
//行走迷宫函数： void Walk (int nx,int ny)
//功能：判断是否已经走出迷宫，如果走出则打印路径，如果没有则开始逐个方向判断是否可以行走，
// 如果都不能行走，或已经返回。则退出该位置，即将该位置的标志写为0表明未走过。
//无返回值，形参nx为当前位置的列，ny为当前位置的行。
---------------------------------------------------------------------------------------------*/
void Walk(int nx,int ny)
{
if (Maze[nx][ny]=='@')//判断是否走出迷宫，@是迷宫出口标志
PrintOut(); //走出则打印出迷宫及行走路径
else //未走出迷宫
{
for (int i=1; i<=4; i++)//四个方向逐个行走，i=1向右 2向下 3向左 4向上
{
if (Judge(nx,ny,i)) //如果列为nx行为ny的位置向i方向是否可以行走
{
MazeFlag[nx][ny]=i;//将标志位置i表明该位置向i方向可行走
if (i==1) //分散处理，根据不同的i来确定下一步的位置，以便行走。
Walk(nx,ny+1);
else if (i==2)
Walk(nx+1,ny);
else if (i==3)
Walk(nx,ny-1);
else if (i==4)
Walk(nx-1,ny);
}
}
MazeFlag[nx][ny]=0;//如果4个方向都走不通，或者回朔则清空该点标志位，置为0表明未走过。
}
}
/*---------------------------------------------------------------------------------------------
//打印函数：void PrintOut()
//功能： 打印第dMeans种方法的在迷宫中的行走路径,以及通过比较找出目前行走步数最少的行走方法。
//无返回值，无形参。dMeans表示当前行走方法的种类。dCount是用来计算此种方法用了多少步。
---------------------------------------------------------------------------------------------*/
void PrintOut()
{
int nx,ny;
double dCount=0;
dMeans++;
cout<<"The "<<dMeans<<" ways is: "<<endl;
for (nx=0;nx<10;nx++)
{
for (ny=0;ny<51;ny++)
{
if (Maze[nx][ny]=='#')//＃表示墙
cout<<"#";
else if (MazeFlag[nx][ny]==0)//不是墙但未走过的地方用空格表示
cout<<" ";
else //不是墙且走过的地方用*表示
{
cout<<".";
dCount++; //走一步总步数加1
}
}
cout<<endl;
}
cout<<"This way used "<<dCount<<" steps"<<endl;
if (dCount<dWalkLen)//如果此种方法的步数比以前方法中最少步数还要少，
{ //则将此种方法列为当前最少行走步数
for (nx=0;nx<10;nx++)
for(ny=0;ny<51;ny++)
MazeMin[nx][ny]=MazeFlag[nx][ny];
dWalkLen=dCount;
}
}
/*--------------------------------------------------------------------------------------------
//判断函数：int Judge(int nx,int ny,int i)
//功能： 判断当前位置(nx为列ny为行)向第i方向行走是否可以
//返回值int型 返回1表明可以，0表示不可以
--------------------------------------------------------------------------------------------*/
int Judge(int nx,int ny,int i)
{
if (i==1)//判断向右可否行走
{
if (ny<50&&(Maze[nx][ny+1]==' '||Maze[nx][ny+1]=='@')&&MazeFlag[nx][ny+1]==0)
return 1;
else
return 0;
}
else if (i==2)//判断向下可否行走
{
if (nx<9&&(Maze[nx+1][ny]==' '||Maze[nx+1][ny]=='@')&&MazeFlag[nx+1][ny]==0)
return 1;
else
return 0;
}
else if (i==3)//判断向左可否行走
{
if (ny>0&&(Maze[nx][ny-1]==' '||Maze[nx][ny-1]=='@')&&MazeFlag[nx][ny-1]==0)
return 1;
else
return 0;
}
else if (i==4)//判断向上可否行走
{
if (nx>0&&(Maze[nx-1][ny]==' '||Maze[nx-1][ny]=='@')&&MazeFlag[nx-1][ny]==0)
return 1;
else
return 0;
}
else
return 0;
}
int main(int argc, char* argv[])
{
int nx,ny,ni,nj;
cout<<"迷宫游戏: "<<endl;
for (ni=0;ni<10;ni++)//输出迷宫形状，并且找到迷宫的入口，同时将迷宫标志初始化
{
for(nj=0;nj<51;nj++)
{
cout<<Maze[ni][nj];
MazeFlag[ni][nj]=0;//将迷宫标志初始化为0表示未走过
if (Maze[ni][nj]=='%')
{
nx=ni;//迷宫入口列坐标
ny=nj;//迷宫入口行坐标
}
}
cout<<endl;
}
cout<<endl<<"入口坐标:"<<endl<<"nx= "<<nx<<" "<<"ny= "<<ny<<endl;
Walk(nx,ny);//调用行走迷宫函数，从入口处开始行走
cout<<endl<<"The MinLen way is: "<<endl;
for (nx=0;nx<10;nx++)//输出最短路径
{
for (ny=0;ny<51;ny++)
{
if (Maze[nx][ny]=='#')
cout<<"#";
else if (MazeMin[nx][ny]==0)
cout<<" ";
else
{
cout<<".";
}
}
cout<<endl;
}
cout<<"This Way used "<<dWalkLen<<" steps"<<endl;//输出最短路径总行走步数
return 0;
}
Ⅳ 按键精灵如何制作走1步才显示下1步的，随机迷宫的脚本
找个会A星算法的高手来吧。。。
Ⅵ 如何用scratch制作障碍迷宫
可以参考这个例子（但它编的不好），再自己加改进
我自己有编过一个，如果你要的话，可以把你的邮箱给我，O(∩_∩)O
Ⅶ 想找个QQ三国靠谱点的行脚脚本，谁那里有啊
上淘宝买吧 ， 淘宝上那些是专业做脚本的，跟自己做的不一样，是脚本就会被封 没什么靠谱不靠谱的
Ⅷ 洛奇英雄传魔方迷宫脚本怎么做
这个有点麻烦，先要去弄个控制台，然后要会用按键精灵，别去网上下了什么迷宫自动里练级带枣脚本了，都有盗号木号。这东山行让西除非自己做或有可以信任的朋友做的，不然这种东西里都会有木马，别人好不容易做逗局出来的东西怎么可能随便就放到网上让大家用，这是个利益分明的社会。想做，先去学做按键精灵吧，基础很简单，学会的话玩很多游戏都用得着（比如有些游戏自动打怪自动捡钱什么的）。
网上下的控制台也有参插木马，自己去网上查查怎么查杀dll文件里的潜藏木马吧。
Ⅸ 用51单片机做的小车如何实现小车走迷宫
硬件电路我就不说了,主要说说算法.
1. 先从一种比较简单的迷宫说起,我称之为"二叉树"迷宫,即每个节点上最多连接三条支路,换句话 说,就是当你面对岔路时,你最多只有三个选择,要么左转,要么右转,要么回头.
假如,我们将左转编码为0,右转编码为1,则迷宫的从入口到出口的路径为一串二进制编码.对于最棚答帆短路径,我们可以让机器人多走几次迷宫,得到一系列二进制串,位数最少的即为"局部最短路径".我们还可以通过这些二进制串,得到迷宫"局部拓扑结构",一种二叉树结构.
注意,在上面的结果上我都加有"局部"两字,这是因为机器人走迷宫的次数如果不够多,或则说少于迷宫的总路径数,我们得到结果都是不完整的,只有当机器人走迷宫的次数足够大,以致于走遍了迷宫所有的路径,这时我们才能得到完整的结果,然而这对于大多数迷宫来说都是不可实现的,也就是说,我们得到的链雹结果都是局部的,最多是趋近于全局结果.
不知大家发现没有,上面还有一种情况我没有编码,那就是回退.这个问题处理起来比较复杂,因此不能仅仅用一位二进制码来表示,必须有专门的处理机制.
这个机制分为三个方面,
一是,每次只回退一步,即当前方无路可走时,回到上一个叉路口,选择另一举型条支路,程序上就是将当前二进制串减少一位,并将改变后的二进制串的最后一位取反,代表选另一条支路.
二是, 回退一步后,仍无路可走时,再回退一部,重复上述过程,直至有岔路可选.
三是,整个回退过程中,记录并保存每次回退的路径,即左右转向的二进制编码,一个回退过即既是由开始回退到开始前进的整段过程.保留这些二进制串,是因为可以通过他们反推得出迷宫的一些局部的拓扑结构
2. 熟悉上面"二叉树迷宫"后 ,对于一般迷宫通过如下方法设计
一、估计出迷宫最大的支路数,即一个叉路口最多有几条岔路，这里假设为a
二 、用a为二进制码对每一个岔路编码，例如我们可以按顺时针编码
三、 将a为二进制编码代替“二叉树迷宫 ”的一位二进制，其它步骤相仿即可。
当然，我们也可以用变长二进制码表示一次路径选择，不过这时得记录保存每次选则对应的二进制码的长度。
补充：
上面的算法，我说的都很笼统，但总体思路是明确的，即：以迷宫入口为根节点，每个叉路口为一个节点，每个岔路为一段树枝，每个树枝用一定位数的二进制码编码，以树形结构表示迷宫的拓扑结构，于是迷宫的通路可以表示为从树的根节点到某一叶节点的路径。
硬件电路上，主要有两个方面的设计：一是，前进河和回退两个状态的识别与转换；二是，岔路的识别与选择。
以上都是个人观点，思考并不周全，还望大家指正补充。
Ⅹ 能不能帮我写一个挂机脚本``装备寄存员，幻境7层 幻境迷宫 到幻境8层的挂机脚本么
你可以去查逗物做
或者自己写下
很容易的
你把脚本蚂唯套山衡用下就可以 改几个地方就OK 了