Ⅰ 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 了