چگونه بازی دوز را بنویسم؟

[mortezamsp]

باسلام.

من قصد دارم بازی دوز را در سی پلاس بنویسم.بازی دوز این طور است که در یک جدل n در n دو بازیکن نقطه ها را به نوبت بچینند و هر کدام که زودتر توانست یک خط با چهار نقطه بسازد برنده است.

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

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

[kashaneh]

دوست عزیز توضیحات ارائه شده توسط شما با موضوع سوال که دوز بود کلی فرق داره!!! بازی مورد نظر شما همان بازی نقاط و خط هاست که به ازای هر مربع تولید شده یک امتیاز در نظر می گرفتیم و ارتباطی با دوز که چیدن سه مهره در یک خط است ندارد... موفق باشی

[mortezamsp]

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

[zoofa]

با سلام
من هم نياز به الگوريتم اين بازي دارم
اگه دوستان لطف كنند و توضيح بدهند ممنون مي شم
با تشكر

[xxxxx_xxxxx]

تو هر دوتاش از الگوريتم MinMax استفاده ميشه.

[zoofa]

با سلام
من يه گشتي زدم
چند تا pdf پيدا كردم درباره minmax
اگه بتونيم با هم همكاري كنيم خيلي خوب مي شه




http://mainline.brynmawr.edu/Courses/cs330/spring2008/ImportantAlgorithms/JBillings(Minimax).pdf (http://mainline.brynmawr.edu/Courses/cs330/spring2008/ImportantAlgorithms/JBillings%28Minimax%29.pdf)


http://www.cs.man.ac.uk/~schalk/3192/sol4.pdf (http://www.cs.man.ac.uk/%7Eschalk/3192/sol4.pdf)

[zoofa]

سلام
اين مقاله هم درباره هوش مصنوعي

http://ceit.aut.ac.ir/islab/courses/DAI/files/slides/khalilian%20thesis%20-%20Design%20and%20Implementation%20a%20Framework%2 0to%20Construct%20the%20Database%20of%20Classic%20 Problems%20in%20Artificial%20Intelligence.pdf

[zoofa]

سلام
دوستان من اين برنامه را نوشتم اما هوشمند نيست هنگامي كه نوبت كامپيوتر است از ميان خانه هاي خالي يكي را به صورت رندوم انتخاب مي كند و انتخاب مي كند.
اين بازي كامل است فقط نياز به هوشمند شدن دارد
برنامه پويا است كه با قرار دادن max_value در خط پنج مي توان تعداد سطر و ستون را مشخص كرد.
اگه دوستان مايلند كه همكاري كنند و كاملش كنيم همين جا پيام بديد
لطفاً نظرتون را درباره برنامه بديد
با تشكر



#include <conio.h>
#include <stdlib.h>
#include <iostream.h>
#define max_value 5
enum { computer = 2 , human = -2 };
int array[max_value][max_value] = { 0 };
int turn = computer;
int near_win(int *ai , int *aj)
{
int count , i , j;
//satr computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[i][j];
if ( count == ( max_value - 1 ) * computer )
for ( j = 0 ; j < max_value ; j++)
if ( array[i][j] == 0 )
{
*ai = i;
*aj = j;
return computer;
}
}

count = 0;
//sotoon computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[j][i];
if ( count == ( max_value - 1 ) * computer )
for ( j = 0 ; j < max_value ; j++ )
if ( array[j][i] == 0 )
{
*ai = j;
*aj = i;
return computer;
}
}
count = 0;
//ghotr1 computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
count += array[i][i];

if ( count == ( max_value - 1 ) * computer )
for ( i = 0 ; i < max_value ; i++ )
if ( array[i][i] == 0 )
{
*ai = i;
*aj = i;
return computer;
}
//ghotr2 computer *******************************************
int ccount = max_value;
count = 0;
for ( i = 0 ; i < max_value ; i++ )
count += array[i][--ccount];

ccount = max_value;

if ( count == ( max_value - 1 ) * computer )
for ( i = 0 ; i < max_value ; i++ )
if ( array[i][--ccount] == 0 )
{
*ai = i;
*aj = ccount;
return computer;
}

//satr human *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[i][j];

if ( count == ( max_value - 1 ) * human )
for ( j = 0 ; j < max_value ; j++)
if ( array[i][j] == 0 )
{
*ai = i;
*aj = j;
return human;
}
}
//sotoon human *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[j][i];
if ( count == ( max_value - 1 ) * human )
for ( j = 0 ; j < max_value ; j++ )
if ( array[j][i] == 0 )
{
*ai = j;
*aj = i;
return human;
}
}
//ghotr1 human *******************************************
count = 0;
for ( i = 0 ; i < max_value ; i++ )
count += array[i][i];

if ( count == ( max_value - 1 ) * human )
for ( i = 0 ; i < max_value ; i++ )
if ( array[i][i] == 0 )
{
*ai = i;
*aj = i;
return human;
}
//ghotr2 human*******************************************
ccount = max_value;
count = 0;
for ( i = 0 ; i < max_value ; i++ )
count += array[i][--ccount];

ccount = max_value;

if ( count == ( max_value - 1 ) * human )
for ( i = 0 ; i < max_value ; i++ )
if ( array[i][--ccount] == 0 )
{
*ai = i;
*aj = ccount;
return human;
}

return 0;
}
//************************************************** **********
int win()
{
int count , i , j;
//satr computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[i][j];
if ( count == ( max_value ) * computer ) return computer;
if ( count == ( max_value ) * human ) return human;

}

//sotoon computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
{
count = 0;
for ( j = 0 ; j < max_value ; j++)
count += array[j][i];
if ( count == ( max_value ) * computer ) return computer;
if ( count == ( max_value ) * human ) return human;
}
count = 0;
//ghotr1 computer *******************************************
for ( i = 0 ; i < max_value ; i++ )
count += array[i][i];

if ( count == ( max_value ) * computer ) return computer;
if ( count == ( max_value ) * human ) return human;

//ghotr2 computer *******************************************
int ccount = max_value;
count = 0;
for ( i = 0 ; i < max_value ; i++ )
count += array[i][--ccount];

ccount = max_value;

if ( count == ( max_value ) * computer ) return computer;
if ( count == ( max_value ) * human ) return human;
return 0;
}

//************************************************** **********
void position ( int pos , int *ai , int *aj)
{

if ( pos % max_value == 0 )
{
*aj = max_value - 1;
*ai = pos / max_value - 1;
}
else
{
*ai = pos / max_value;
*aj = pos % max_value - 1;

}
}


void get_position()
{
int flag = 0;

int pos , i , j;
do
{
//gotoxy ( 0 , 80 );
cout << endl << endl << endl << endl;
if ( flag > 0 ) cout << "InCorrect Choise. Try Again" << endl;

cout << "Please Enter The Position" << endl;
cin >> pos;

position ( pos , &i , &j );
flag++;
}while ( array[i][j] != 0 );
array[i][j] = human;
clrscr();
}
void get_position_computer()
{
//int flag = 0;
//cout << "Please Wait...\n";
int pos , i , j;
do
{

pos = (random( max_value * max_value )) + 1;
position ( pos , &i , &j );

}while ( array[i][j] != 0 );
array[i][j] = computer;
clrscr();
}
//************************************************** ****************
void table()
{
clrscr();
int i = 0 , j = 0;
// 217:ظ 218:ع 179: ³ 180: ´ 182 191:؟ 192: ہ
// 193: ء 194:آ 195: أ 196:ؤ 197:إ 198:

cout << "ع";
for ( i = 0 ; i < max_value ; i++ )
{
cout << "ؤؤؤؤؤ";
if ( i != max_value - 1 ) cout << "آ";

}
cout << "؟";

for ( i = 0 ; i < max_value ; i++ )
{
cout << endl;
for ( j = 0 ; j <= max_value ; j++ )
{
cout << "³";
if ( j != max_value )
cout << " ";
}
cout << endl;
if ( i != max_value - 1 )
cout << "أ";
else
cout << "ہ";
for ( j = 0 ; j < max_value ; j++ )
{
cout << "ؤؤؤؤؤ";
if ( i != max_value - 1 )
{
if ( j != max_value - 1 )
cout << "إ";
else
cout << "´";
}
else
{
if ( j != max_value - 1 )
cout << "ء";
else
cout << "ظ";
}
}
}
}
void show()
{
int i , j ;
table();
for ( i = 0 ; i < max_value ; i++ )
{
for ( j = 0 ; j < max_value ; j++)
{
if ( array[i][j] == computer )
{
gotoxy ( (j * 5) + 4 + j , (i * 1) + 2 + i );
cout << "X";
}
else if ( array[i][j] == human )
{
gotoxy ( (j * 5) + 4 + j , (i * 1) + 2 + i );
cout << "O";
}

}
cout << endl;
}
//gotoxy ( 0 , 500 );
}
//************************************************** ******************
void move ()
{
//gotoxy ( 100 , 100 );
//cout << " " ;
if ( turn == computer )

{
cout << endl << endl << endl << endl;
cout << "Please Wait...";
//delay(1000);
get_position_computer();
//cout << "Computer Turn";

//show();

turn = human;
}
else
{
get_position();
turn = computer;
}

}
//************************************************** **********
int main()
{
clrscr();
randomize();
int pos = 0 , i , j;
do
{

//get_position();
move();
show();
pos = win();
}while ( pos == 0 );
show();
cout << endl << endl << endl << endl;
if ( pos == computer ) cout << "Sorry. You Lost The Game";
else cout << "Congratulation! . You Won The Game!";

//pos = near_win ( &i , &j );
//clrscr();

//cout << endl << pos << " , " << i << " , " << j;
getch();
return 0;
}

[zoofa]

سلام
اين طور كه من متوجه شدم براي هوشمند شدن بايد از درخت استفاده كرد
كه از درخت چندتايي و درخت دودويي مي توان استفاده كرد كه درخت چندتايي پيچيده تر نسبت به درخت دودويي مي باشد اما هوشمندتر است و نتيجه‌ي بهتري دارد.

يك چيز ديگه هم متوجه شدم اين است كه نياز به يك تابع داريم كه مشخص كند آيا خانه‌اي است كه با يك حركت ديگر منجر به برد يكي از بازيكنان ( كامپيوتر و يا انسان) بشود كه من آن را در برنامه نوشتم اما استفاده نكردم به نام near_win
اگر خانه اي با شرط فوق بود بايد آن در اولويت قرار دهيم و اگر هم كاربر و هم كامپيوتر هر دو چنين شرايطي دارند كه با يك حركت ديگر برنده بازي باشند اولويت با كامپيوتر است تا مسدود كردن راه كاربر
اميدوارم درست بيان كرده باشم
با تشكر
منتظر همكاريتان هستم ....... :چشمک::چشمک::چشمک::چشمک::چشمک:

[mortezamsp]

با سلام.

ممنون كه پي گير بحث هستيد.بابت برنامه ای که نوشتید خیلی ممنون.خسته نباشید.اجرا کردم و خوب بود.مثل اینکه اولویت برد با بازیکن هستش.

من هم فكر كردم و راهي كه به ذهنم رسيد اين بود كه براي انتخاب خانه بعدي توسط كامپيوتر ، بايد دو ملاك را در نظر داشته باشيم.يكي مسدود كردن مسير حريف و يكي پيش بردن مهره هاي خودمان.براي اين كار من يك آرايه جديد ساختم كپي آرايه اصلي و در اون خونه هايي كه مال حريف هستند و دارن پر ميشن رو با يه امتياز و خونه هايي كه مال كامپيوترن و دارم پر ميشن رو هم با يه امتياز مقداردهي كنه.و در آخر پر امنياز ترين خونه رو انتخاب كنه.اين ساده ترين راهه و ميتونه حد اقل يك حركت بعدي رو پيش بيني كنه.


نظر شما چيه؟

[zoofa]

سلام دوست عزیز
ببخشید که دیر شد
چند وقت درگیر فکر کردن بودم و سلولهای خاکستری مغزم دائماً درحال تکاپو بودند و فسفر می سوزوندند!!!!! تا بالاخره نوشتمش
با درخت چند تایی نوشتم و برنامه تمام حالت های ممکن را بررسی می کند و بهترین حالت را انتخاب می کند. از همون الگوریتم مینیمکس استفاده کردم.
برنامه تا حالت n * n را جواب می دهد اما وقتی که از 3 * 3 بیشتر شود زمان خیلی زیادی طول می کشد که یک حرکت را انجام دهد.
اگر در مورد الگوریتم و یا خود برنامه سوالی دارید در خدمتم:لبخندساده:
راستی نظرتون درباره برنامه را یادتون نره
خوشحال می شم نظرتون را بدونم
یادم رفت بگم که اگر تونستید ازش ببرید آواتارم را عوض می کنم:قهقهه::قهقهه::قهقهه::قهق� �ه::قهقهه:
یعنی محاله که ازش ببرید!!!!!!!



#include <conio.h>
#include <mem.h>
#include <stdlib.h>
#include <iostream.h>
#define max_value 3
//************************************************** ************************************************** ************************
double mcount = 0;
enum { computer = 2 , human = -2 };
int array[max_value][max_value];

//[max_value][max_value] = { 0 };
int turn = computer;
struct node
{
int mat[max_value][max_value];
node *p[max_value][max_value];
}*matroot;
//************************************************** ************************************************** ***********************
void matrix_copy ( int dest[max_value][max_value] , int source[max_value][max_value] )
{
int i , j;
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
dest[i][j] = source[i][j];
}
//************************************************** ************************************************** ***********************
int matrix_status( int mat[max_value][max_value] )
{
int i , j , row_plus , column_plus , empty_count = 0;
for ( i = 0 ; i < max_value ; i++ )
{
row_plus = 0;
column_plus = 0;
for ( j = 0 ; j < max_value ; j++ )
{
row_plus += mat[i][j];
column_plus += mat[j][i];
if ( mat[i][j] == 0 ) empty_count++;
}
if ( row_plus == max_value * computer || column_plus == max_value * computer ) return computer;
if ( row_plus == max_value * human || column_plus == max_value * human ) return human;
}

int max = max_value;
row_plus = 0;
column_plus = 0;
for ( i = 0 ; i < max_value ; i++ )
{
row_plus += mat[i][i];
column_plus += mat[i][--max];
}
if ( row_plus == max_value * computer || column_plus == max_value * computer ) return computer;
if ( row_plus == max_value * human || column_plus == max_value * human ) return human;
if ( !empty_count ) return 1;
return 0;
}

//************************************************** ************************************************** ***********************
creat_tree ( node *mat , int turn , int *ii , int *ij , int *counter )
{
int status , turn_temp;
int i , j ;

status = matrix_status ( mat->mat );
if ( status ) return status;
int value[max_value][max_value]={0};
int count_value[max_value][max_value]={0};

for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( turn == computer )
value[i][j] = -10;
else
value[i][j] = 10;


node *ptr;
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
{
if ( mat->mat[i][j] == 0 )//&& cell_status ( mat->mat , i , j , turn ) )
{
ptr = (node*) malloc ( sizeof ( node ));
matrix_copy ( ptr->mat , mat->mat );
ptr->mat[i][j] = turn;
if ( turn == computer ) turn_temp = human;
else turn_temp = computer;
mcount++;
value[i][j] = creat_tree ( ptr , turn_temp , &*ii , &*ij , &count_value[i][j] );

free(ptr);

}
}
int minmax , ai , aj;
int c_value = 0;
if ( turn == computer )
{
minmax = -10;

for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] > minmax )
{
minmax = value[i][j];
ai = i;
aj = j;
}
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] == minmax )
{
c_value++;
ai = i;
aj = j;
}

*counter = c_value;
c_value = 0;
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] == minmax && count_value[i][j] > c_value )
{
c_value++;
ai = i;
aj = j;
}
*ii = ai;
*ij = aj;
return minmax;

}
else
{
minmax = 10;

for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] < minmax )
{
minmax = value[i][j];
ai = i;
aj = j;
}
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] == minmax )
{
c_value++;
ai = i;
aj = j;
}

*counter = c_value;
c_value = 0;
for ( i = 0 ; i < max_value ; i++ )
for ( j = 0 ; j < max_value ; j++ )
if ( value[i][j] == minmax && count_value[i][j] > c_value )
{
c_value++;
ai = i;
aj = j;
}
*ii = ai;
*ij = aj;
return minmax;

}
}
//************************************************** ************************************************** ***********************
void creat_root(int mat[max_value][max_value] , int *ii , int *ij )
{
matrix_copy ( matroot->mat , mat );
int count;
creat_tree ( matroot , computer, &*ii , &*ij , &count );
}

//************************************************** ************************************************** *******************
int movecomputer()
{
int i , j;
creat_root(array , &i , &j);
array[i][j] = computer;

return 0;
}
//************************************************** **********
void position ( int pos , int *ai , int *aj)
{

if ( pos % max_value == 0 )
{
*aj = max_value - 1;
*ai = pos / max_value - 1;
}
else
{
*ai = pos / max_value;
*aj = pos % max_value - 1;

}
}


void move_human()
{
int flag = 0;

int pos , i , j;
do
{
//gotoxy ( 0 , 80 );
cout << endl << endl << endl << endl;
if ( flag > 0 ) cout << "InCorrect Choise. Try Again" << endl;

cout << "Please Enter The Position" << endl;
cin >> pos;

position ( pos , &i , &j );
flag++;
}while ( array[i][j] != 0 );
array[i][j] = human;
clrscr();
}

//************************************************** ****************
void table()
{
clrscr();
int i = 0 , j = 0;
// 217:ظ 218:ع 179: ³ 180: ´ 182 191:؟ 192: ہ
// 193: ء 194:آ 195: أ 196:ؤ 197:إ 198:

cout << "ع";
for ( i = 0 ; i < max_value ; i++ )
{
cout << "ؤؤؤؤؤ";
if ( i != max_value - 1 ) cout << "آ";

}
cout << "؟";

for ( i = 0 ; i < max_value ; i++ )
{
cout << endl;
for ( j = 0 ; j <= max_value ; j++ )
{
cout << "³";
if ( j != max_value )
cout << " ";
}
cout << endl;
if ( i != max_value - 1 )
cout << "أ";
else
cout << "ہ";
for ( j = 0 ; j < max_value ; j++ )
{
cout << "ؤؤؤؤؤ";
if ( i != max_value - 1 )
{
if ( j != max_value - 1 )
cout << "إ";
else
cout << "´";
}
else
{
if ( j != max_value - 1 )
cout << "ء";
else
cout << "ظ";
}
}
}
}
//************************************************** *************************************
void show()
{
int i , j ;
table();
for ( i = 0 ; i < max_value ; i++ )
{
for ( j = 0 ; j < max_value ; j++)
{
if ( array[i][j] == computer )
{
gotoxy ( (j * 5) + 4 + j , (i * 1) + 2 + i );
cout << "X";
}
else if ( array[i][j] == human )
{
gotoxy ( (j * 5) + 4 + j , (i * 1) + 2 + i );
cout << "O";
}

}
cout << endl;
}
//gotoxy ( 0 , 500 );
}
//************************************************** ******************
void move ()
{
//gotoxy ( 100 , 100 );
//cout << " " ;
if ( turn == computer )

{
cout << endl << endl << endl << endl;
cout << "Please Wait...";
//delay(1000);
movecomputer();
//movecomputer();
//cout << "Computer Turn";

show();

turn = human;
}
else
{
move_human();
turn = computer;
}

}
//************************************************** **********
int main()
{
clrscr();

randomize();
int pos = 0 , i , j;
do
{

//get_position();
move();
show();
pos = matrix_status(array);

}while ( pos == 0 );
show();
cout << endl << endl << endl << endl;
if ( pos == computer ) cout << "Sorry. You Lost The Game";
else if ( pos == human ) cout << "Congratulation! . You Won The Game!";
else cout << "Not Complete";

//pos = near_win ( &i , &j );
//clrscr();


getch();
return 0;
}

[xxxxx_xxxxx]

برنامه تا حالت n * n را جواب می دهد اما وقتی که از 3 * 3 بیشتر شود زمان خیلی زیادی طول می کشد که یک حرکت را انجام دهد.

به خاطر عمق زياد درخت هست كه بايد الگوريتم بهينه شه.
از روشي موسوم كه هرس آلفا-بتا براي بهينه كردن الگوريتم استفاده كنيد. در اين حالت بسياري از گره ها ديگه نيازي به بررسي شدن ندارند و سرعت برنامه به مراتب افزايش پيدا مي كنه.

[mortezamsp]

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

#include<dos.h>
//=================================
void initmouse()
{
_AX=0;
geninterrupt(0x33);
}
void showmouse()
{
_AX=1;
geninterrupt(0x33);
}
void restrictmouse(int x1,int y1,int x2,int y2)
{
_AX=7;
_CX=x1;
_DX=x2;
geninterrupt(0x33);
_AX=8;
_CX=y1;
_DX=y2;
geninterrupt(0x33);
}
void getmouse(int *button,int *x,int *y)
{
_AX=3;
geninterrupt(0x33);
*button=_BX;
*x=_CX;
*y=_DX;
}
//=================================
#include<iostream.h>
#include<conio.h>
#include<stdlib.h>
#include<graphics.h>
//=================================
const int size=6;
int aray[size][size];
int game_level; //0:easy,1:hard
int raray[size][size]; //ranking aray
//================================
void print()
{
int i,j;
for(i=0;i<=size-1;i++)
for(j=0;j<=size-1;j++)
{
//rectangel(10+(i*20),10+(j*20),10+(i+1)*20,10+(j+1) *20);
if(aray[i][j]==1)
{
setcolor(4);
circle((i+1)*20,(j+1)*20,10);
}
else if(aray[i][j]==2)
{
setcolor(1);
circle((i+1)*20,(j+1)*20,10);
}
else if(aray[i][j]==0)
{
setcolor(12);
circle((i+1)*20,(j+1)*20,10);
}
}
setcolor(7);
bar(140,140,240,155);
setcolor(5);
outtextxy(145,145,"main menu");
}
//==============================
void next_home(int &nexti,int &nextj)
{
int i,j,k; //counters
int rank;
for(i=0;i<size;i++)
for(j=0;j<size;j++)
raray[i][j]=0;
///rank all aray into raray
for(i=0;i<size;i++)
for(j=0;j<size;j++)
{
if(aray[i][j]==1) //user
{
//1
rank=0;
for(k=0;k<3;k++)
{
if(aray[i-k][j]==1 && i-k>=0)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j]==0)
raray[i-k][j]+=rank+game_level;
//2
rank=0;
for(k=0;k<3;k++)
{
if(aray[i+k][j]==1 && i+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j]==0)
raray[i+k][j]+=rank+game_level;
//3
rank=0;
for(k=0;k<3;k++)
{
if(aray[i][j+k]==1 && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i][j+k]==0)
raray[i][j+k]+=rank+game_level;
//4
rank=0;
for(k=0;k<3;k++)
{
if(aray[i][j-k]==1 && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i][j-k]==0)
raray[i][j-k]+=rank+game_level;
//5
rank=0;
for(k=0;k<3;k++)
{
if(aray[i+k][j+k]==1 && i+k<size && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j+k]==0)
raray[i+k][j+k]+=rank+game_level;
//6
rank=0;
for(k=0;k<3;k++)
{
if(aray[i+k][j-k]==1 && i+k<size && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j-k]==0)
raray[i+k][j-k]+=rank+game_level;
//7
rank=0;
for(k=0;k<3;k++)
{
if(aray[i-k][j+k]==1 && i-k>0 && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j+k]==0)
raray[i-k][j+k]+=rank+game_level;
//8
rank=0;
for(k=0;k<3;k++)
{
if(aray[i-k][j-k]==1 && i-k>0 && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j-k]==0)
raray[i-k][j-k]+=rank+game_level;
}
if(aray[i][j]==2) //computer
{
//1
rank=1;
for(k=0;k<3;k++)
{
if(aray[i-k][j]==2 && i-k>=0)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j]==0)
raray[i-k][j]=rank;
//2
rank=1;
for(k=0;k<3;k++)
{
if(aray[i+k][j]==2 && i+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j]==0)
raray[i+k][j]=rank;
//3
rank=1;
for(k=0;k<3;k++)
{
if(aray[i][j+k]==2 && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i][j+k]==0)
raray[i][j+k]=rank;
//4
rank=1;
for(k=0;k<3;k++)
{
if(aray[i][j-k]==2 && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i][j-k]==0)
raray[i][j-k]=rank;
//5
rank=1;
for(k=0;k<3;k++)
{
if(aray[i+k][j+k]==2 && i+k<size && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j+k]==0)
raray[i+k][j+k]=rank;
//6
rank=1;
for(k=0;k<3;k++)
{
if(aray[i+k][j-k]==2 && i+k<size && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i+k][j-k]==0)
raray[i+k][j-k]+=rank;
//7
rank=1;
for(k=0;k<3;k++)
{
if(aray[i-k][j+k]==2 && i-k>0 && j+k<size)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j+k]==0)
raray[i-k][j+k]=rank;
//8
rank=1;
for(k=0;k<3;k++)
{
if(aray[i-k][j-k]==2 && i-k>0 && j-k>0)
rank++;
else
{
k++;
break;
}
}
if(aray[i-k][j-k]==0)
raray[i-k][j-k]=rank;
}
}
//find raray home with max rank
int maxr=0;
int maxi=0;
int maxj=0;
for(i=0;i<size;i++)
for(j=0;j<size;j++)
if(raray[i][j] >= maxr) // > ? >=
{
maxr=raray[i][j];
maxi=i;
maxj=j;
}
nexti=maxi;
nextj=maxj;
}
//==============================
void rank_1(int mode)
{
int rank1=0,rank2=0;
for(int i=0;i<=size-1;i++)
for(int j=0;j<=size-1;j++)
{
if(aray[i][j]==1 && aray[i-1][j+1]==1 && aray[i-2][j+2]==1
&& aray[i-3][j+3]==1 && i-3>=0 && j+3<=size-1)
rank1++;
if(aray[i][j]==2 && aray[i-1][j+1]==2 && aray[i-2][j+2]==2
&& aray[i-3][j+3]==2 && i-3>=0 && j+3<=size-1)
rank2++;

if(aray[i][j]==1 && aray[i][j+1]==1 && aray[i][j+2]==1
&& aray[i][j+3]==1 && j+3<=size-1)
rank1++;
if(aray[i][j]==2 && aray[i][j+1]==2 && aray[i][j+2]==2
&& aray[i][j+3]==2 && j+3<=size-1)
rank2++;

if(aray[i][j]==1 && aray[i+1][j+1]==1 && aray[i+2][j+2]==1
&& aray[i+3][j+3]==1 && i+3<=size-1 && j+3<=size-1)
rank1++;
if(aray[i][j]==2 && aray[i+1][j+1]==2 && aray[i+2][j+2]==2
&& aray[i+3][j+3]==2 && i+3<=size-1 && j+3<=size-1)
rank2++;

if(aray[i][j]==1 && aray[i+1][j]==1 && aray[i+2][j]==1
&& aray[i+3][j]==1 && i+3<=size-1)
rank1++;
if(aray[i][j]==2 && aray[i+1][j]==2 && aray[i+2][j]==2
&& aray[i+3][j]==2 && i+3<=size-1)
rank2++;
}
clrscr();
if(rank1>rank2)
{
gotoxy(5,20);
if(mode==2)
{
cout<<" YOU WON ";
cout<<"\nrank of user= "<<rank1
<<"\nrank of computer= "<<rank2<<"\n";
}
if(mode==1)
{
cout<<" user 1 won ";
cout<<"\nrank of user1= "<<rank1
<<"\nrank of user2= "<<rank2<<"\n";
}

}
else if(rank1==rank2)
{
gotoxy(5,20);
cout<<"ranks are the same.no one won";
}
else if(rank1<rank2)
{
gotoxy(5,20);
if(mode==2)
{
cout<<" GAME OVER ";
cout<<"\nrank of computer= "<<rank2
<<"\nrank of userr= "<<rank1<<"\n";
}
if(mode==1)
{
cout<<" user 2 won ";
cout<<"\nrank of user2= "<<rank2
<<"\nrank of user1= "<<rank1<<"\n";
}
}

}
//=============================
void getm(int &a,int &b)
{
int x,y,button;
while(button!=1)
{
showmouse();
getmouse(&button,&x,&y);
}
a=(x+10)/20;
b=(y+10)/20;
}
//=============================
void game_2()
{
int x,y;

int beginner;
gotoxy(5,20);
cout<<"who is the beginner?(1:user,2:computer)";
cin>>beginner;
beginner=(beginner%2)+1;

int turn=beginner;
int d=(size*size)-1;
for(int i=0;i<d;i++)
{
clrscr();
print();
repet:
if(turn==1)
{
getm(x,y);
if(x==7 && y==7)
break;

if(aray[x-1][y-1]!=0) //just give a new entered home
{
outtextxy(20,220,"invalid adress.enter again!");
goto repet;
}
aray[x-1][y-1]=1;
turn=2;
continue;
}
if(turn==2)
{
next_home(x,y);
aray[x][y]=2;
turn=1;
continue;
}
}
}
//=============================
void game_1()
{
int x,y;
int turn=1;
int count=0;
int end=size*size;
while( count!=end )
{
clrscr();
print();
g: getm(x,y);
if(x==7 && y==7) //exiting code
break;
if(x>7 || y>7)
{
gotoxy(5,20);
cout<<"invalid adress!enter again.";
goto g;
}
if(aray[x-1][y-1]!=0) //tekrary nagire
goto g;

if(turn==1)
{
aray[x-1][y-1]=1;
turn=2;
count++;
continue;
}
if(turn==2)
{
aray[x-1][y-1]=2;
turn=1;
count++;
continue;
}
}
clrscr();
outtextxy(20,240,"game finished!press any key to view ranks.");
getch();
}
//=============================
void run_game()
{
int choise=0;
while(choise!=3)
{
clrscr();
cout<<"\n\tG A M E D O O Z"
<<"\n\nselect:\n1:play user with user2,"
<<"\n2:play user with computer,\n3:exit";
cin>>choise;
if(choise>=3)
choise=3;
if(choise<=1)
choise=1;
clrscr();
for(int i=0;i<=size-1;i++)
for(int j=0;j<=size-1;j++)
aray[i][j]=0;
if(choise==1)
{
game_1();
rank_1(1);
getch();
}
if(choise==2)
{
clrscr();
gotoxy(5,12);
cout<<"easy:1 , hard:2";
cin>>game_level;
game_level=(game_level)%2+1;

game_2();
rank_1(2);
getch();
}
}
}
//=============================
void main()
{
clrscr();
int gd=DETECT ,gm;
initgraph(&gd,&gm,"c:\\tc\\bgi");
run_game();
closegraph();
}