שניי עדכונים:

1. אני אמור לבנות פונקציה שתאפס את כל המטריצה ולפזר בה באופן רנדומאלי מס' מסויים של מוקשים.

מקומות ללא מוקשים = 0.

מקומות עם מוקשים = 1 .

לא הבנתי איך להגריל מס' מסויים של 1 במטריצה , לדוגמא 10 מוקשים במטריצה של 40 על 40 .

#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
void main()
{
  int x, y, msarray[50][50],rndmmeans;
  clrscr();
  for(x=0; x<39; x++)
  {
    for(y=0; y<39; y++)
    {
    rndmmeans=random(2);
    msarray[x][y]=rndmmeans;
    }
  }
  for(x=0; x<39;x++)
  {
  cout<<"\n";
    for(y=0; y<39; y++)
    {
cout<<msarray[x][y]<<" ";
    }
  }
getch();
}

2. לבנות תוכנית של עכבר : היום השאלתי ספר של C כדי לרשום מתוכו את התוכנית של העכבר.

    כבר בפונקציה הראשונה שרשומה בספר יש בעייה.

#include<dos.h>

int mouse_status(int *buttons)
{
union REGS ireg;


ireg.x.ax = 0x00;
int86(0x33, &ireg, &ireg);
*buttons = ireg.x.bx;
return ireg.x.ax;
}

הפונקציה צריכה להחזיר 0 אם לא נמצא עכבר ו1 אם נמצא עכבר.

יש שם משהו שלא מתקמפל מסיבה לא ידועה.

תודה מראש לעוזרים.

דרך פשוטה להגריל מיקום של מוקש זה להגריל x ו- y בטווח (בין 0 ל- 39), ואם כבר יש שם מוקש לחזור על הפעולה.

אם תתן את הודעת השגיאה יהיה הרבה יותר קל לעזור לך.

לגבי הגרלת המוקש לא הבנתי את כוונתך :-\

נגיד אם יש לי מערך של 9 על 9 כלומר 81 מקומות במערך שיש בהם 0 , יהיו שם 10 מוקשים שהמייצג שלהם הוא 1 .

לגבי העכבר , השגיאה שמופיעה ככה :

Linker Error: Undefined symbol _main in in module c0.ASM

לגבי הגרלת המוקש לא הבנתי את כוונתך :-\

נגיד אם יש לי מערך של 9 על 9 כלומר 81 מקומות במערך שיש בהם 0 , יהיו שם 10 מוקשים שהמייצג שלהם הוא 1 .

הוא אמר לך

תעשה לולאה שחוזרת 10 פעמים ובכל מחזור היא תגריל 2 מספרים(אחד לקורדינטת X והשני ל-Y) ותמלא את המיקום הנבחר ב-1 במקום 0

אם אתה נופל על מקום שכבר יש בו אחד, אתה חוזר ומגריל שני מספרים נוספים

Linker Error: Undefined symbol _main in in module c0.ASM

בדר"כ זה אומר שבפרוייקט שלך אין פונקציית main, או שמשום מה הקובץ שבו פונקציית main נמצא לא מתלקנג' עם שאר הפרוייקט. יכול להיות שזה המצב?

הבעייה שהייתה לי שגיאת כתיב

הצלחתי להפעיל את העכבר , הוא גם עובד נהדר.

יש לי בעייה עם הפונקציית RANDOM או RANDOMIZ או RAND (כולם מתאימים) , הם תמיד מחזירים את אותו פלט זהה בכל הרצה.

המורה שלי אמר שצריך לרשום ערך גבוה ואז זה ירענן אותו אבל זה גם לא עובד , מה הצעתכם?

#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
#include <stdlib.h>
#include <dos.h>
void MinesweeperArr(int size)
{
int i,j,x,mnsw[50][50];
clrscr();

for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
mnsw[i][j]=x=random(30000)%2;
}
}
//====Output !!!

for(i=0;i<size;i++)
{
cout<<"\n\n";
for(j=0;j<size;j++)
{
cout<<setw(3)<<mnsw[i][j];
}
}
getch();
}

void main()
{
int sz=10;
MinesweeperArr(sz);
}

המורה שלך אומר שלראנדום להכניס ערך קבוע ישנה את התוצאה??

תחליף מורה מהר

את הפונקציה ראנדום חייבים לאתחל עם הפונקציה SRAND ובא להכניס ערך שמשתנה

בדרך כלל מכניסים לשם את הזמן של המחשב

יש ירד לי המיוט.

בכל מקרה, יש בBORLAND C פונ (ותר נכון כמה קבועים) שעושים את זה אוטומטית. תרשום randomize(); בתחילת התוכנית ותבדוק אם עובד לך.

עריכה: תשלח לי את החלק של העכבר.

אתה צריך לקרוא ל- randomize פעם אחת בתחילת התוכנית כדי לאתחל את המנגנון של המספרים האקראיים (מן הסתם זה נעשה לפי השעון), ובכל פעם להשתמש ב- random.

לפרמטר שאתה מעביר לו אין משמעות ב"ערבול" המספרים, כי מה שבעצם קורה זה שמוגרל מספר בין 0 ל- MAX_INT ונעשה מודולו בפרמטר שאתה מעביר לו.

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <dos.h>
#include <time.h>
#include <iomanip.h>

void MinesweeperArr(int size)
{
int mnsw[50][50];
int i,j;
int xi,yi;
int mns_num=0,NumMineMis;
time_t t;

clrscr();
srand((unsigned) time(&t));

if(size%2==0)size++;

for(i=0; i<size; i++)
   {
   for(j=0; j<size; j++)
      {
      mnsw[i][j]=0;
      }
   }

for(i=0; i<size*size*0.2; i++)
   {
   xi=rand()%size;
   yi=rand()%size;
   mnsw[xi][yi]=10;
   }

for(i=0; i<size-2; i++)
   {++i;
   for(j=0; j<size-2; j++)
      {++j;

      if(mnsw[i][j]==10)mnsw[i][j]=0;

      NumMineMis=mnsw[i-1][j-1]+mnsw[i-1][j]+mnsw[i-1][j+1]+
mnsw[i]  [j-1]       +      mnsw[i]  [j+1]+
mnsw[i+1][j-1]+mnsw[i+1][j]+mnsw[i+1][j+1];

      mnsw[i][j]=NumMineMis/10;

      }
   }


//====Pelet (hamhasha)

for(i=0;i<size;i++)
    {
    cout<<"\n\n";
    for(j=0;j<size;j++)
       {
       cout<<setw(3)<<mnsw[i][j];
       }
    }

for(i=0; i<size; i++)
   {
   for(j=0; j<size; j++)
      {if(mnsw[i][j]==10)mns_num++;}
   }
cout<<"\n\n"<<mns_num<<" Mines!\n";

getch();
}

void main()
{
int sz=23;
MinesweeperArr(sz);
}

שמתי לב לבעייה (אפילו לא ידעתי עליה -> *אני בקושי יודע איך לשחק במשחק שאני בונה*) : אומנם הוא כבר בודק טוב את המוקשים מסביב ומציב באמצע את מס' המוקשים , אך שמתי לב שבמשחק יכולים להיות צירופים צמודים של מספרים האומרים כמה מוקשים יש מסביב.

וזה ממש סיבך אותי כרגע . (אני אפילו לא יכול לחשוב על אלגוריתם לפיתרון)

1) אתה צריך לבדוק אם אתה לא בצדדים.

2)למה אתה עושה מספר אי-זוגי?

3) בחלק של הבחירת תאים- למה עשית את זה ככה?

4) למה אתה מאפס מוקש(בלולאה השניה).

5) אל תוסיף את אלה בצדדים, תוסיף את !(a-10) כאשר A זה התא.

בעיקרון 1+4+5 יוצרים לך את הבעיה(ועכשיו אני שם לב לעוד כמה דברים).

תחשוב שאתה עובר תא תא, ובודק, אם יש לו שכן, תבדוק אם הוא מוקש(אם הערך בו הוא 10), ואם כן, תעלה ב- 1.

for(i=0;i<size;i++)
for(j=0;j<size;j++)
{
if(mnsw[i][j]!=10)
  mnsw[i][j]=( j-1>=0 ? !(mnsw[i][j-1]-10) : 0 )...
}

וכו.אני לא זוכר אם בתנאי המקוצר הוא מחשב קודם את הכל ואחר כך בודר, או ההפך, ולכן אם הוא נותן שגיאת זיכרון, "תרחיב" את התנאי.

או שבמקום השורה הארוכה הזו אתה יכול לשלוח אותו לפונ שמחשבת כמה יש מסביבו על אותו עיקרון(יותר יפה).

הצלחתי (עם קצת הרבה קוד) לבנות את השדה מוקשים ומספרים מייצגים.

לפעמים נמצא במערך מס' שמייצג מס' שגוי של מוקשים מסביב , לדוגמא: 2 ויש רק מוקש אחד מסביבו.

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <dos.h>
#include <time.h>
#include <iomanip.h>

void MinesweeperArr(int size)
{
int mnsw[50][50];
int i,j;
int xi,yi;
int mns_num=0,NumMineMis;
time_t t;

clrscr();
srand((unsigned) time(&t));

for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
mnsw[i][j]=0;
}
}

for(i=0; i<size*size*0.2; i++)
{
xi=rand()%size;
yi=rand()%size;
mnsw[xi][yi]=10;
}


for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
if(mnsw[i][j]!=10)
{ //Bdikat Pinot

if(i==0 && j==0){ //up:left
NumMineMis=mnsw[i][j+1]+mnsw[i+1][j]+mnsw[i+1][j+1];
mnsw[i][j]=NumMineMis/10;}
if(i==0 && j==size-1){ //up:right
NumMineMis=mnsw[i][j-1]+mnsw[i+1][j-1]+mnsw[i+1][j];
mnsw[i][j]=NumMineMis/10;}
if(i==size-1 && j==0){ //down:left
NumMineMis=mnsw[i-1][j]+mnsw[i-1][j+1]+mnsw[i][j+1];
mnsw[i][j]=NumMineMis/10;}
if(i==size-1 && j==size-1){ //down:right
NumMineMis=mnsw[i-1][j-1]+mnsw[i-1][j]+mnsw[i][j-1];
mnsw[i][j]=NumMineMis/10;}

//Bdikat Misgeret

if(i==0 && j>0 && j<size-1){ //up:line
NumMineMis=mnsw[i][j-1]+mnsw[i][j+1]+mnsw[i+1][j-1]+mnsw[i+1][j]+mnsw[i+1][j+1];
mnsw[i][j]=NumMineMis/10;}
if(i==size-1 && j>0 && j<size-1){ //down:line
NumMineMis=mnsw[i-1][j-1]+mnsw[i-1][j]+mnsw[i-1][j+1]+mnsw[i][j-1]+mnsw[i][j+1];
mnsw[i][j]=NumMineMis/10;}
if(j==0 && i>0 && i<size-1){ //left:line
NumMineMis=mnsw[i-1][j]+mnsw[i-1][j+1]+mnsw[i][j+1]+mnsw[i+1][j]+mnsw[i+1][j+1];
mnsw[i][j]=NumMineMis/10;}
if(j==size-1 && i>0 && i<size-1){ //right:line
NumMineMis=mnsw[i-1][j-1]+mnsw[i-1][j]+mnsw[i][j-1]+mnsw[i+1][j-1]+mnsw[i+1][j];
mnsw[i][j]=NumMineMis/10;}

//Bdikat Merkaz

if(i>0 && j>0 && i<size-1 && j<size-1)
{
NumMineMis=mnsw[i-1][j-1]+mnsw[i-1][j]+mnsw[i-1][j+1]+
mnsw[i] [j-1] + mnsw[i] [j+1]+
mnsw[i+1][j-1]+mnsw[i+1][j]+mnsw[i+1][j+1];
mnsw[i][j]=NumMineMis/10;}

}

}

}


//====Pelet (hamhasha) !!!___________________________________

for(i=0;i<size;i++)
{
cout<<"\n\n";
for(j=0;j<size;j++)
{
cout<<setw(3)<<mnsw[i][j];
}
}

for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{if(mnsw[i][j]==10)mns_num++;}
}
cout<<"\n\n"<<mns_num<<" Mines!\n";

getch();
}

void main()
{
int sz=10;
MinesweeperArr(sz);
}

נראה לי שמצאתי את הבעיה, והיא נובעת בעיקר מזה שאתה מעדכן את המערך שלך תוך כדי המעבר עליו -

נגיד שעברת על תא X שלא נמצא ליד מוקש אבל לידו יש תאים שליד כל אחד מהם יש 3 או 4 מוקשים (בסה"ך 10 מוקשים).

כמו שאתה עובד, אתה תספור את התאים שלידו, תקבל 10, ותסיק שיש ליד X מוקש.

למה שלא תעדכן את המספרים תוך כדי זה שאתה שם את המוקשים?

אתה גם יכול במקום 9 משפטי IF לעשות את זה בלולאה אחת (מכוננת) יותר פשוטה שבה אתה מריץ את i ו- j בין מינוס 1 ל- 1 ובודק שאתה בטווח של המערך (ומדלג אם i==j==0)

שמתי לב גם שאתה עלול לשים מוקש באותו מקום פעמיים.

1. נראה לי שמצאתי את הבעיה, והיא נובעת בעיקר מזה שאתה מעדכן את המערך שלך תוך כדי המעבר עליו -

נגיד שעברת על תא X שלא נמצא ליד מוקש אבל לידו יש תאים שליד כל אחד מהם יש 3 או 4 מוקשים (בסה"ך 10 מוקשים).

כמו שאתה עובד, אתה תספור את התאים שלידו, תקבל 10, ותסיק שיש ליד X מוקש.

2. למה שלא תעדכן את המספרים תוך כדי זה שאתה שם את המוקשים?

3. אתה גם יכול במקום 9 משפטי IF לעשות את זה בלולאה אחת (מכוננת) יותר פשוטה שבה אתה מריץ את i ו- j בין מינוס 1 ל- 1 ובודק שאתה בטווח של המערך (ומדלג אם i==j==0)

4. שמתי לב גם שאתה עלול לשים מוקש באותו מקום פעמיים.

1. אה! , אתה בעצם אומר שאני סופר לא רק את ה"10" אלא גם מס' אחרים שאם מחברים יוצא "10" ואז אני סופר אותו כמוקש? אם אני אבדוק שמסביב אמורים להיות רק "10" אז הבעייה תפתר ?

2. לא הבנתי איך אני ימספר תאים לייד המוקשים כשאני עוד מגריל אותם , צריך לסרוק אותם אחרי ההשמה לא?

3. לא הבנתי כל כך את כוונתך.

4. זה בגלל שאני מגריל אותם רנדומלית במערך? -> זה בגלל שלא הצלחתי להגריל מס' מוקשים מסויים. אבל אני אנסה שוב.

אה! , אתה בעצם אומר שאני סופר לא רק את ה"10" אלא גם מס' אחרים שאם מחברים יוצא "10" ואז אני סופר אותו כמוקש? אם אני אבדוק שמסביב אמורים להיות רק "10" אז הבעייה תפתר ?

בדיוק.

למה שלא תעדכן את המספרים תוך כדי זה שאתה שם את המוקשים?

במקום לעשות מעבר שני אחרי שאתה שם את המוקשים, בכל פעם שאתה שם מוקש, תעבור על (מקסימום 8) התאים שלידו, ותעדכן בהם את מספר המוקשים שלידם.

לא הבנתי כל כך את כוונתך

אתה יכול עבור כל מוקש לרוץ בלולאה על הסביבה שלו (בגודל 3x3) ולבדוק בכל תא אם הוא נמצא בתוך הלוח (כי למשל עבור התא 0,0 אתה תתחיל מ- -1, -1 שנמצא מחוץ ללוח)

זה בגלל שאני מגריל אותם רנדומלית במערך? -> זה בגלל שלא הצלחתי להגריל מס' מוקשים מסויים. אבל אני אנסה שוב.

הדרך הכי פשוטה תהיה לעשות שאם הגרלת מקום שכבר יש בו מוקש, תגריל עוד פעם מיקום, עד שתגיע למקום שבו עדיין אין מוקש.