نوشتن بازی مسیریاب توسط ++c

[FunnyVacation]

سلام دوستان
من تازه شروع کردم به کار با C++ حالا هم چند تا برنامه بهم گفتن بنویس که تو این برنامه که پایین می گم زیادی گیر کردم و نتونستم بنویسم.

حالا امیدوارم با توجه به تجربیات اساتید فن بشه این برنامه نوشته بشه و شرش از سرم کم بشه چون فکرم را مشغول کرده و مهمتر از آن یه چیزی هم یاد بگیرم.

حالا می خوام بازی مسیریابی طراحی کنم به این صورت :

این بازی جدولی دو بعدی به عنوان محیط بازی دارد.
یک نقطه شروع و یک نقطه پایان دارد.
هدف : یافتن مسیری از نقطه شروع تا پایان است.
برخی از خانه های جدول دیوار هستند که نمی توان از روی آنها حرکت کرد. برخی دیگر خانه های خالی برای حرکت کردن هستند.
لذا مسیری که در نهایت اعلام می کنیم باید از تمام خانه های مجاز جدول عبور کند و با دیوارها تلاقی نداشته باشد.
از یک خانه هم نباید دو بار عبور کرد.
به علاوه نوع خاصی از دیوارها کشنده هستند. به این معنی که نمی توان بیش از دو حرکت در یکی از 8 خانه اطراف آن داشته باشیم. حداکثر بعد از 2 حرکت در کنار یکی از آنها از کنار آن دور می شویم.

-------- نوع ورودی ---- :
نقطه اول شامل 2 عدد Col , Row باشد . پس از آن جدولی به اندازه Col*row خانه شامل کارکترهای زیر داده می شود :
S خانه شروع X دیوارهای معمولی Yدیوارهای کشنده Eخانه پایان . (نقطه) خانه خالی که محل عبور است

---------نوع خروجی ----- :
در هر سطر از خروجی مختصات نقطه ای از مسیر حرکت را می نویسیم
ابتدا مختصات محور X و سپس Y ( نقطه (0و0) گوشه بالا سمت چپ است ).
شروع با مختصات S و پایان با مختصات E

در صورت عدم وجود جواب عبارت No Solutron را چاپ کند.

به صورت Rand() دیوار چینی می کند.

نمونه :

S – X_ _
_ _ _ _ _
Y _ _ Y _
_ _ X _ _
_ _ _ _ E



تا 20 این ماه فرصت دارم تمومش کنم .

ممنون از کمکای دوستان

 

[saalek110]

ّبرنامه آموزشی: پیدا کردن مسیر

یک نگاهی اینجا بیانداز.

 

[shirini_forush]

من اول با دقت شروع کردم به خوندن فکر کردم داری آموزش میدی
کلا هر جا اسم کوتاه ترین مسیر رو شنیدی برو تو نخ گراف و bfs.
یکم الگوریتم مطالعه کنی دستت میاد.
کد bread first search و depth first search رو هم قبلا گذاشتم.

 

[saalek110]

http://binky.org.uk/software/docs/mazegen.txt
فکر کنم سایت بالا راهنمای طرز ایجاد maze باشه.

http://www.programmersheaven.com/mb/CandCPP/89522/89522/readmessage.aspx
در اینجا هم بحث سر ساختن maze است.
================================
منبع:
http://matroid.blogfa.com/post-3.aspx
-----------------------------------------------
هزارتو- ماز (maze) قسمت دوم



الگوریتم های حل ماز



1- الگوریتم دنبال کردن دیواره ها

این الگوریتم بهترین روش پیمودن ماز است، که با قانون دست راست یا دست چپ شناخته می شود. اگر ماز ساده باشد، یعنی همه ی دیواره ها به یکدیگر یا فضای بیرونی ماز متصل باشند، این تضمین وجود دارد که با حفظ تماس یک دست به دیواره ای که از آن شروع به حرکت می کنیم، بتوان از ماز خارج شد. ولی اگر ماز ساده نباشد، این الگوریتم به یافتن خروجی در قسمت های گسسته کمکی نمی کند.

الگوریتم دنبال کردن دیواره ها در مازهای سه بعدی نیز عملی است. مثلا در یک ماز سه بعدی مسیر های رو به بالا می توانند شمال غرب و مسیرهای رو به پایین جنوب شرق فرض شوند و با روش دنبال کردن دیواره ها به نتیجه رسید.

2- الگوریتم Pledge

ماز های گسسته را می توان به روش دنبال کردن دیواه ها حل کرد، در صورتی که ورودی و خروجی ماز روی دیواره های خارجی ماز قرار داشته باشند. چنانچه از درون ماز شروع به حرکت کنیم، ممکن است الگوریتم دنبال کردن دیواره ها در قسمت گسسته ای که شامل خروجی نیست دائما یک حلقه را طی کند. الگوریتم Pledge می تواند این گونه مسائل را حل کند.

الگوریتم Pledge برای رفع موانع، به طی یک مسیر اختیاری نیاز دارد. هنگام مواجهه با مانع،یک دست (مثلا دست راست) را در امتداد مانع نگه می داریم در حالیکه زوایای چرخش شمرده می شود. وقتی دوباره در راستای مسیر اصلی قرار گرفتیم و جمع زاویه ای چرخش ها برابر صفر شد، می توان مانع را ترک کرد و در راستای مسیر اصلی حرکت نمود. این الگوریتم به شخص اجازه ی جهت یابی را در شروع از هر نقطه برای خارج از مازهای دوبعدی، را می دهد.



3- الگوریتم جستجوی تصادفی

این الگوریتم یک روش ضعیف است که به وسیله ی ربات های غیر هوشمند یا موش قابل اجراست، اما تضمینی برای رسیدن به هدف وجود ندارد. در این الگوریتم یک مسیر مستقیم طی می شود تا به اولین مانع برسد، سپس یک مسیر تصادفی را برای ادامه انتخاب می کند. این الگوریتم در صورتی که خروجی به صورت یک سوراخ در میانه ی دیوار باشد، با شکست مواجه می شود.



4- الگوریتم Tremaux

الگوریتم Tremaux یک روش کارآمد است که در آن مسیرهای طی شده با رسم خطوط نشان دار می شوند. این الگوریتم برای همه ی مازهایی که مسیر های خوش تعریف دارند، عملی است. با رسیدن به تقاطع های بی نشان، می توان یکی از جهت های ممکن را انتخاب کرد. اگر یک تقاطع قبلا طی شده باشد می توان مسیر طی شده را باز گشت. اگر نیاز به طی مسیری باشد که نشان دار است، می توان خط دیگری رسم کرد و تقاطع بعدی ممکن است شامل مسیر غیر نشان دار باشد. در این روش نیاز به طی مسیری بیش از دو بار نمی باشد و اگر خروجی وجود نداشته باشد، این روش با نقطه ی شروع ماز بر می گردد.

=====================================
از:
http://matroid.blogfa.com/post-4.aspx

هزارتو – ماز (maze) قسمت آخر



تولید ماز ها



روش های متفاوتی برای تولید خودکار ماز ها وجود دارد. روش مبتنی بر پشته یکی از ساده ترین روش های تولید ماز به وسیله ی کامپیوتر است. فضای ماز را به صورت شبکه ی وسیعی از خانه ها (سلول ها) در نظر بگیرید.(مانند یک صفحه ی شطرنج بسیار بزرگ) هر خانه با اتصال 4 دیوار ساخته شده است. از یک خانه به طور تصادفی شروع می کنیم. سپس کامپیوتر به طور تصادفی یکی از خانه های بررسی نشده ی مجاور را انتخاب می کند. دیواره ی بین دو خانه را حذف می کند و یک خانه ی جدید به پشته اضافه می کند. کامپیوتر این فرایند را ادامه می دهد تا به خانه ای برسد که هیچ همسایه ی بررسی نشده ای نداشته باشد. در این حالت به بن بست می رسد. وقتی در بن بست قرار گرفت، تمامی مسیر را بر می گردد تا به خانه ای برسد که همسایه ی بررسی نشده ای دارد. این فرایند تا جایی ادامه پیدا می کند که همه ی خانه ها بررسی شده باشند و سپس کامپیوتر تمامی مسیر را تا رسیدن به خانه ی اولیه بر می گردد. این روش بررسی تمام خانه های ماز را تضمین می کند. همانطور که گفته شد این الگوریتم بسیار ساده است و ماز های بسیار پیچیده را تولید نمی کند. می توان با افزودن شرط هایی به این الگوریتم ماز های دشوارتری ایجاد کرد.

=============================================

مسئله خيلي جالب و سخت حركت موش

 

[FunnyVacation]

با توجه به اونهایی که به ما یاد دادن یکم زیادی سخته !!!

 

[FunnyVacation]

یکی از دوستان یه الگوریتمی به این شکل پیشنهاد داد :
علی آقا اول یه جدول تعریف کن :

Row = col = 20

Jadval[col 1][row 1]



2) با حلقه و با دستور rand()%(col 1) , rand()%(row 1) مثلا 20 تا آرایه جدول رو بهش مقدار -1 بده!(این نشانه دیوار بودن آن خانه است.)

بعضی از خونه ها رو -2 نشانه دیوار کشنده بودن است .



3) حالا باید با حلقه for تو در تو دونه دونه خونه های جدول رو پیمایش کنی و 2 شرط زیر رو همیشه رعایت کنی:

شرط اول : اگر به خونه -1 خوردی یعنی دیوار باید مسیرت رو عوض کنی ،

شرط دوم : اگر به خونه های کنار-2 رسیدی یعنی 8 تا خونه کناری جدول کشنده باید خونه بعدیت هم چک کنی اگه اونهم کنار دیوار کشنده بود باید دفعه بعدی به خونه کناریش نری ! ( با یه شرط ساده)



میدونم خیلی سخت توضیح دادم
و بعد برای توضیح شرط دوم :
خونه های -2 یعنی دیوار کشنده

خونه های -1 یعنی دیوار معمولی

خونه های دیوار کشنده رو باید براش شمارشگر بذاری تا 2 تا شد دفعه دیگه نره طرف دیوار کشنده.



نوشتن این برنامه مستلزم اینه که خوب با حلقه های تکرار بازی کنی




نظر شما چیه ؟
من درست شرط دوم را نمی تونم بفهمم
میشه یه کمکی بکنید !!

 

[shirini_forush]

ببینید.
هر فرد کند ذهنی هم میتونه هر مساله ای رو حل کنه. توی حل که بحثی نیست.
شما به این توجه کنید که order الگوریتم و growth of function بالا نباشه.
الگوریتمی که بخواد با چند تا حلقه این کار رو انجام بده شک نکید حداقل order ش n2 خواهد بود.

 

[saalek110]

برای راحتی خودت وقتی خانه کشنده را داری می کاری خانه های اطرافش که خانه های داغ هست را هم با عدد خاصی مشخص کن که موش تکلیف خودش را بداند.

اگر این کار را نکنی موش باید به هر خانه که می رسد برود استعلام بگیرد ببیند آیا در 8 خانه همسایگی اون خانه آیا خانه کشنده هست یا نه.


--------------------------
راجع به شمارشگر هم موشه باید یک شمارنده داشته باشه که وقتی دید دو تا (یا هر چیزی برنامه گفته) خانه داغ را لگد کرده خودش را سوخته حساب کنه و برگرده. البته اگر مسئله را درست فهمیده باشم.

 

[FunnyVacation]

سفیر جان
من باید یه چیزی بنویسم که استاد نامرد درس داده باشه

یا حداقل ازش سر در بیارم

-------------
یه نکته :
من اینجا که هستم هیچ کتاب و جزو ای دستم نیست همه را جا گذاشتم
با این حساب هر چی بلدم باید رو کنم

این که گفتی یعنی چه ؟

شما به این توجه کنید که order الگوریتم و growth of function بالا نباشه.

 

[FunnyVacation]

مسیریاب**********
اون مسیر خرگوش که پایین پستت بود دقیقا راه حلی هست که من می خواستم:
چند تا تغییر کوچیک می خواد
باید با استفاده از random و ranmomize مساله ایجاد بشه
از یک مسیر هم 2 بار نره

دیوار کشنده را هم بی خیال
ببین می تونی کاریش بکنی ؟



*************
منم یکم به این دوز ور برم تا 4 در 4 بشه

 

[FunnyVacation]

#include <iostream.h>
#include<conio.h>
//using namespace std;

int col = 1;
int row = 2;
const int ROWMAX = 11;
const int COLMAX = 16;

char maze[ROWMAX][COLMAX] =
{
{'B','B','B','B','B','B','B','B','B','B','B','B','B','B','B','B'},
{'S',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B',' ','B','B','B',' ','B'},
{'B','W',' ',' ',' ',' ',' ',' ',' ','B',' ','B',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B',' ','B',' ','B'},
{'B',' ',' ',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B','B','B',' ','B'},
{'B',' ',' ',' ','B',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B'},
{'B',' ','B','B','B',' ','B','B','B','B','B','B',' ','B','B','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B','B','B','B',' ','B','B'}
};
void printMaze();
void runMaze(int, int);


void printMaze()
{
for(int row = 0; row < ROWMAX; row++)
{
for(int col=0; col < COLMAX; col++)
cout << maze[row][col];
cout << "\n";
}
}

void runMaze(int row, int col)
{
if( (row>0 && row<ROWMAX) && (col>0 && col<COLMAX))
{
if( maze[row][col] == 'W'){
return;
;
}
if( maze[row][col] == ' ')
{
maze[row][col]='-';
runMaze(row, col+1);
runMaze(row, col-1);
runMaze(row-1, col);
runMaze(row+1, col);

}
}
}

int main()
{
cout << "Maze before solution:\n";
cout << "\n";
printMaze();
cout << ":\n";
cout << "Maze after solution:\n";
cout << "\n";
runMaze(1, 2);
cout<<"\n";
cout<<"\n";
printMaze();
getch();
return 0;
}


ببین می تونی این دو مشکل را حال کنی ؟

 

[FunnyVacation]

تابع بازگشتی دوباره فراخوانی شود
به این شکل که چک کند ببیند اگر به چند راهی برسد ، مختصات چند راهی را ذخیره کند ، مسیری را برود و ببیند به بن بست می خورد یا نه اگر خورد برگردد اگر نخورد همان را ادامه بدهد.
در غیر اینصورت به مختصات برگردد و مسیر دیگر را برود و اگر در کل به نتیجه نرسید پیغام عدم موفقیت را بدهد.
در مسیر انتخابی اگر به خانه خالی رسیدیم * می کنیم


یه چیزی تو این مایه ها

می تونی کاریش بکنی ؟

 

[saalek110]

برنامه ای که در پی سی ورد بود را خواندم.
http://forum.p30world.com/showthread.php?t=79812

منطقش را فهمیدم. چند خط هم اضافه کردم تا معلوم بشه موش موفق شده یا نه.

#include <iostream.h>
//using namespace std;
[COLOR="Red"]int successful=0[/COLOR];
int col = 1;
int row = 2;
const int ROWMAX = 11;
const int COLMAX = 16;

char maze[ROWMAX][COLMAX] =
{
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'},
{'B','M',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B',' ','B','B','B',' ','B'},
{'B','W',' ',' ',' ',' ',' ',' ',' ','B',' ','B',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B',' ','B',' ','B'},
{'B',' ',' ',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B','B','B',' ','B'},
{'B',' ',' ',' ','B',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B'},
{'B',' ',' ',' ',' ',' ',' ',' ','B','B','B','B',' ','B','B','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'}
};
void printMaze();
void runMaze(int, int);


void printMaze()
{
	for(int row = 0; row < ROWMAX; row++)
	{
	for(int col=0; col < COLMAX; col++)
	cout << maze[row][col];
	cout << "\n";
	}
}

void runMaze(int row, int col)
{
	if( (row>0 && row<ROWMAX) && (col>0 && col<COLMAX))
	{
		if( maze[row][col] == 'W' )
                                       [COLOR="#ff0000"]{[/COLOR]
                                        [COLOR="#ff0000"]successful=1[/COLOR]; 
                                        return;
                                       [COLOR="#ff0000"] }[/COLOR]

		if( maze[row][col] == ' ')
		{
			maze[row][col]='*';

			runMaze(row, col+1);
			runMaze(row, col-1);
			runMaze(row-1, col);
			runMaze(row+1, col);
		}
	}
}

int main()
{
	cout << "Maze before solution:\n";
	printMaze();
	cout << "Maze after solution:\n";
	runMaze(1, 2);
	printMaze();
    [COLOR="#ff0000"]if (successful==1) cout<<"mouse is successful"[/COLOR];
	return 0;
}

برنامه بالا پیغام mouse is successful را چاپ می کند ولی با آرایه زیر :

char maze[ROWMAX][COLMAX] =
{
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'},
{'B','M',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B',' ','B','B','B',' ','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ','B',' ','B',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B',' ','B',' ','B'},
{'B','W',' ',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B','B','B',' ','B'},
{'B',' ',' ',' ','B',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B'},
{'B',' ',' ',' ',' ',' ',' ',' ','B','B','B','B',' ','B','B','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'}
};

این پیغام چاپ نمی شود.

 

[saalek110]

سلام.
برنامه پست قبل را به شکل زیر تغییر دادم تا مسیر حرکت موش را ببینی.

#include <iostream.h>
[COLOR="Blue"]#include <conio.h>[/COLOR]
//using namespace std;
int successful=0;
[COLOR="Red"]int direction=1;[/COLOR]
int col = 1;
int row = 2;
const int ROWMAX = 11;
const int COLMAX = 16;

char maze[ROWMAX][COLMAX] =
{
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'},
{'B','M',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B',' ','B','B','B',' ','B'},
{'B','W',' ',' ',' ',' ',' ',' ',' ','B',' ','B',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B',' ','B',' ','B'},
{'B',' ',' ',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B','B','B',' ','B'},
{'B',' ',' ',' ','B',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B'},
{'B',' ',' ',' ',' ',' ',' ',' ','B','B','B','B',' ','B','B','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'}
};
void printMaze();
void runMaze(int, int);


void printMaze()
{
	for(int row = 0; row < ROWMAX; row++)
	{
	for(int col=0; col < COLMAX; col++)
	cout << maze[row][col];
	cout << "\n";
	}
}

void runMaze(int row, int col)
{
	if( (row>0 && row<ROWMAX) && (col>0 && col<COLMAX))
	{
		if( maze[row][col] == 'W' )
                                       {
                                        successful=1; 
                                        return;
                                        }

		if( maze[row][col] == ' ')
		{
			maze[row][col]='*';

			runMaze(row, col+1);
			runMaze(row, col-1);
			runMaze(row-1, col);
			runMaze(row+1, col);
		}
	}
[COLOR="Blue"]
	for (int m1=1;m1<10000;m1++)  for (int m2=1;m2<10000;m2++);
	gotoxy (col+1, row+1); cout<< maze[row][col];[/COLOR]
}

int main()
{
	[COLOR="#0000ff"]//[/COLOR]cout << "Maze before solution:\n";
	printMaze();

	runMaze(1, 2);
		[COLOR="#0000ff"]//[/COLOR]cout << "Maze after solution:\n";
		[COLOR="#0000ff"]//[/COLOR]	printMaze();
	[COLOR="#0000ff"] //[/COLOR]if (successful==1) cout<<"mouse is successful";
	return 0;
}

در توربوسی 4 و نیم اجرا شد. در توربو سی 3 شاید هدر gotoxy چیز دیگری باشد ولی احتمالا همین است.

به جای تابع sleep که در توربوسی 4 و نیم هدرش در dos.h است از حلقه تودرتو استفاده کردم چون کامپایلر من میگفت sleep را نمیشناسه.

خوبی برنامه اینه که نشون میده موش کجا داره قدم می زنه.

یک متغیر به نام direction تعریف کردم(البته برنامه اش در برنامه بالا موجود نیست - فقط متغیرش هست) که موش اول گیر بده فقط به سمت راست بره. اگر مقدار return به معنی راه بسته بود به پایین بره و الی آخر. یعنی تابع runMaze را از حالت void در آوردم و int کردم تا اعلام کنه چه کرده. تا حدودی برنامه کار می کرد فقط فکر کنم آخر شیفت از راست به پایین و چپ و بالا باید در آخر کدها در تابع بازگشتی می گفتیم دایرکشن را دوباره راست کن و باز همه را امتحان کن.

 

[saalek110]

در آخر پست قبل گفتم باید دایرکشن تعریف بشه . در این پست برنامه اش را می زنم. جهت راست را فقط فعلا دادم.
FunnyVacation جان ببین می تونی تکمیلش کنی.

#include <iostream.h>
#include <conio.h>
//using namespace std;
int successful=0;
int direction=1;
int col = 1;
int row = 2;
const int ROWMAX = 11;
const int COLMAX = 16;

char maze[ROWMAX][COLMAX] =
{
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'},
{'B','M',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B',' ','B','B','B',' ','B'},
{'B','W',' ',' ',' ',' ',' ',' ',' ','B',' ','B',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B',' ','B',' ','B'},
{'B',' ',' ',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B',' ','B'},
{'B','B','B','B','B','B','B','B',' ','B','B','B','B','B',' ','B'},
{'B',' ',' ',' ','B',' ',' ',' ',' ','B',' ',' ',' ',' ',' ','B'},
{'B',' ',' ',' ',' ',' ',' ',' ','B','B','B','B',' ','B','B','B'},
{'B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','B'},
{'B','B','B','B','B','B','B','B','B','B','B','B',' B','B','B','B'}
};
void printMaze();
[COLOR="#0000ff"]int[/COLOR] runMaze(int, int);


void printMaze()
{
	for(int row = 0; row < ROWMAX; row++)
	{
	for(int col=0; col < COLMAX; col++)
	cout << maze[row][col];
	cout << "\n";
	}
}

[COLOR="#0000ff"]int[/COLOR] runMaze(int row, int col)
{
int s1;
	if( (row>0 && row<ROWMAX) && (col>0 && col<COLMAX))
	{
		if( maze[row][col] == 'W' )
                                       {
                                        successful=1; 
                                        return [COLOR="#0000ff"]2[/COLOR];
		[COLOR="#0000ff"]			 [COLOR="DarkSlateGray"]}[/COLOR]
		 if( maze[row][col] == 'B' )  return 0;
		if (direction==1) s1=runMaze(row, col+1);
		if  (s1==0) direction=2[/COLOR];





		 [COLOR="#0000ff"] //[/COLOR]	runMaze(row, col+1);
		[COLOR="#0000ff"]  //[/COLOR]	runMaze(row, col-1);
		  [COLOR="#0000ff"]//[/COLOR]	runMaze(row-1, col);
		  [COLOR="#0000ff"]//[/COLOR]	runMaze(row+1, col);
[COLOR="Blue"]
		if( maze[row][col] == ' ')   	maze[row][col]='*';[/COLOR]
	}
	for (int m1=1;m1<10000;m1++)  for (int m2=1;m2<10000;m2++);
	gotoxy (col+1, row+1); cout<< maze[row][col];
	[COLOR="#0000ff"]return 2[/COLOR];
}

int main()
{
	//cout << "Maze before solution:\n";
	printMaze();

	runMaze(1, 2);
		//cout << "Maze after solution:\n";
		//	printMaze();
	 //if (successful==1) cout<<"mouse is successful";
	return 0;
}

 

[FunnyVacation]

ممنون روش کار می کنم ...
راستی برای رندوم سازی آرایه چیکار کنم ؟
randomize()
random
منتها چجوری بکار ببرم ؟

کار دیوار کشنده را چجوری تعریف کنیم ؟

 

[saalek110]

برای راندم اینجا شاید کمک کند.

 

[FunnyVacation]

سلام
saalek جان
من از اولشم با الگوریتم این برنامه که نوشته شده مشکل داشتم ... شاید چون اصلا درست بازگشتی را نفهمیدم
نمی دونم کسی بجز تابع بازگشتی این را نوشته یا نه ؟
اگه بازگشتی نباشه راحت تر می تونم بفهمم و تغییر بدم
این را که باید دایرکشن تعریف بشه را نوشته بودی را اجرا کردم ...
دفعه اول درست اجرا میشه -- منتها دفعه بعد میریزه به هم ... نمی دونم چرا ؟

راستی return 2 و gotoxy و sleep چیکار می کنه ؟

این خط چیکار می کنه ؟

if (direction==1) s1=runMaze(row, col+1);
if (s1==0) direction=2;


--------------
for (int m1=1;m1<10000;m1++) for (int m2=1;m2<10000;m2++);
gotoxy (col+1, row+1); cout<< maze[row][col];
return 2;

تو خط دوم این کد ، چرا جای Row , Col عوض شده ؟ بخاطر اینه که نمی دونم گو تو ایسک و ایگرگ چیکار می کنه...
--------------

در کل اگه بشه تو الگوریتم این برنامه از بازگشتی استفاده نشه ... حداقل من بهتر می تونم بفهمم ...

 

[FunnyVacation]

ابع gotoxy(a,b) مکان نما را به نقطه ی a,b منتقل میکند و از این پس نوشتن را در آن محل انجام میدهد

پس یعنی بجای پایین به بالا
می شود چپ به راست
اگه درست فهمیده باشم ...

 

[saalek110]

با سلام.

پاسخ سئوالات پست 18 :

تابع بازگشتی خودش را صدا می زند.
اصلا فرض کنید در تابع main وقتی تابع دیگری صدا زده می شود چه اتفاقی می افتد؟
جواب: کدهای آن تابع اجرا میشه و بعد برمیگردد به خطهای بعد صدا زدن تابع در همان main .
در تابع بازگشتی هم وقتی خودش را صدا می زند فرض کنید تابع دیگری را صدا زده. که بعد اجرای آن تابع دیگر باز خطهای بعدی اجرا می شود.
این از توضیح فرآیند به شکل ساده.

اما با نگاهی دقیق تر ما بدنه تابع بازگشتی را به دو قسمت تقسیم می کنیم:
قبل صدا زدن خودش
و بعد صدا زدن خودش.

قسمت اول موقع رفت اجرا میشه و قسمت دوم موقع بازگشت.
به 3 پست زیر توجه کنید:
http://forum.persiantools.com/showpost.php?p=679340&postcount=272
http://forum.persiantools.com/showpost.php?p=679763&postcount=273
http://forum.persiantools.com/showpost.php?p=680017&postcount=274

در کل قسمت دوم بدنه تابع بازگشتی هر چه تابع بالاتر باشه دیرتر اجرا میشه.
مثلا فرض کنید سر سفره هستید و یک دیس پر برنج و ته دیگ به شما می دهند. به شما می گویند برنج را بردار ولی ته دیگ را موقعی بردار که دیس دست به دست بشه تا انتهای سفره برود و برگردد. شما که اول صف هستید اولین نفری هستید که برنج می کشید ولی آخرین نفری هستید که ته دیگ برمی دارید.

پس بایستی کدهایی که می خواهید اول اجرا بشود را در قسمت اول بدنه تابع بگذارید و کدهایی را که می خواهید در آخر اجرا بشود را در قسمت دوم بگذارید.
البته باید مواظب باشید تابع بازگشتی تا ابد خودش را صدا نکند و شرطی باشد که وقتی آن شرط وجود داشته باشد تابع خودش را صدا بزند. من در برنامه های بالا حواسم به این قضیه نبود ولی دچار این مشکل هم نشدم. فعلا دقت نکردم چرا.
سئوال بعد:
من هم کمی فکر کردم که بدون تابع بازگشتی آیا می شود یا نه. ولی چون معلوم نیست که موش چند خانه باید بچرخد انگار تابع بازگشتی لازمه. البته ذکر یک نکته لازم است. و آن اینکه اگر دو یا چند تابع هم همدیگر را با نظم خاصی صدا کنند باز می شود تابع بازگشتی. اگر برایتان آن طوری ملموس تر است شاید اون طور بهتر باشد . البته من کدش را ننوشتم.

سئوال بعدی:
من خیلی ور رفتم به دایرکشن دهی. ولی آخرش نشد که نشد. ساعتها ور رفتم ولی موفق نشدم. اصلا آن را ندیده بگیر که شاید مشکل اضافه کند به جای حل مشکل.

سئوال بعدی:
کلا ریترن مقداری است که تابع بازمی گرداند به کسی(تابعی) که او را صدا زده.
شما در تابع صدا زده شده با برگرداندن مقادیر مختلف به تابع صدا زننده می توانید علامت بدهید به تابع صدا زننده که در تابع صدا شده چه اتفاقی افتاده. من هم با اعداد صفر و 1 و 2 و ... خواستم تابع صدا زننده را برایش توضیح بدهم در تابع صدا زده شده چه اتفاقاتی افتاده.

سئوال بعدی:
تابع gotoxy می آید مکان نما را به موقعیت ایکس و ایگرگ می برد.
تابع sleep باعث مدت زمان مشخصی وقفه در اجرای برنامه می شود. من برای این می خواستم استفاده کنم تا سرعت حرکت موش کند شود تا بفهمم برنامه چه رفتاری از خود نشان می دهد. که خطا داشت کامپایلرم و به جاش یک حلقه تودرتو استفاده کردم تا تاخیر زمانی ایجاد شود.

سئوال بعدی:
آن دو خط کارشان این است که اول نگاه می کنند ببینند دایرکشن به چه سمتی است. اگر یک بود این دایرکشن تابع بازگشتی خودش را صدا می کند. با یک ستون به سمت راست البته. یعنی نتیجه کلا این میشه که موش یک خانه به راست می رود.
اما وقتی به دیوار برمی خورد تابع بازگشتی صفر برمی گرداند پس تابع بازگشتی که خودش را صدا زده می فهمد که در سمت راستش دیوار است و دایرکشن را به 2 تغییر می دهد که مثلا به جای به سمت راست رفتن به سمت پایین رفتن است.

سئوال بعدی:چرا جای ردیف و ستون عوض شده؟
جواب اینکه x و y همان است که در ریاضی داشتیم. یعنی x به سمت راست رفتن است که میشه همان col شما. و سئوال دوم اینکه چرا با یک جمع شده؟ به خاطر اینکه آرایه ای با 5 خانه با شماره های صفر تا 4 شماره زده می شود پس یک را جمع زدیم تا ......