Speicherplätze von Arrays "sperren"

[yus]

Dann erklär du mir mal wie du mit einem 1D Array Effektiv Koordinaten darstellen willst. btw ist das ausserdem nicht die antwort auf meine frage.

[BorisDieKlinge]

mach für jedes Blatt ne datenstruktur, welche ein Aufdekcfalg enthält.

struct BLATT{

  int iblatt
  bool boEnable;

}

BLATT Data[50][50];

.
.
.

if(Data[x][y]) //Aufdecken

P.S.: Bei ner liste würdest du jedes Blatt mit Koordianten (x,y) als struktur ablegen, und die Blätter löschen welche du nich mehr brauchst, so enthält die Liste nur die gewünschten blätter...

[Tachyon]

#define X_DIM 10
#define Y_DIM 10

typedef struct
{
     int uncovered;
     int card_id;
} card_t;

typedef card_t game_t[X_DIM][Y_DIM];

/*...*/

game_t game;
int x;
int y;

/*spielfeld initialisieren. Karten-IDs zuweisen, aufgedeckt auf FALSE*/

/*...*/

/* wenn gleiche karten gefunden */
    game[x1][y1] = TRUE;
    game[x2][y2] = TRUE;

/*...*/

/*die Schleife, die das tut, das Du als "aufdecken bezeichnest*/
for(x = 0; x < X_DIM; ++x)
{
    for(y = 0; y < Y_DIM; ++y)
    {
        if(!game[x][y].uncovered)
        {
            /* hier wird was gemacht */
        }
    }
}

[BorisDieKlinge]

/*die Schleife, die das tut, das Du als "aufdecken bezeichnest*/
for(x = 0; x < (X_DIM *Y_DIM); ++x)
{
        if(!game[x/X_DIM][y%X_DIM].uncovered)
        {
            /* hier wird was gemacht */
        }
}

würde es mit einer schleife machen... weis aber net ob es so geht "ich nix gestestet"

[bingo bongo]

yus schrieb:

Dann erklär du mir mal wie du mit einem 1D Array Effektiv Koordinaten darstellen willst.

array[i] = y * anzahl_spalten + x;

yus schrieb:

btw ist das ausserdem nicht die antwort auf meine frage.

[/quote]

Die Antwort hättest du weiter unten erfahren, wenn du zu ende gelesen hättest.

[Tachyon]

BorisDieKlinge schrieb:

/*die Schleife, die das tut, das Du als "aufdecken bezeichnest*/
for(x = 0; x < (X_DIM *Y_DIM); ++x)
{
        if(!game[x/X_DIM][y%X_DIM].uncovered)
        {
            /* hier wird was gemacht */
        }
}

würde es mit einer schleife machen... weis aber net ob es so geht "ich nix gestestet"

Das hat die gleiche Anzahl an Iterationen, dazu bekommst Du aber noch die sehr teuren (Performance) Modulo-Operationen mit ins Boot.

[fricky]

Tachyon schrieb:

...
typedef struct
{
     int uncovered;
...
} card_t;
...

im kartenspieler-jargon wird hier eher das wort 'revealed' verwendet.

[nubz0rs]

bingo bongo schrieb:

yus schrieb:

Dann erklär du mir mal wie du mit einem 1D Array Effektiv Koordinaten darstellen willst.

array[i] = y * anzahl_spalten + x;

yus schrieb:

btw ist das ausserdem nicht die antwort auf meine frage.

Die Antwort hättest du weiter unten erfahren, wenn du zu ende gelesen hättest. [/quote]

warum einfach wenns auch schwer geht o_O

[Prozessorlastschutzverein]

nubz0rs schrieb:

warum einfach wenns auch schwer geht o_O

klar, ne liste ist etwas umständlicher zu programmieren.
man bedenke aber die vielen sinnlosen for-schleifen durchläufe.
der arme prozessor !!!

[lippoliv]

Ne liste ist auch kompletter schwachsinn...
Was man natürlich machen könnte (würd ich aber nicht tun) ist nen 1D array wo du deine Zahlen wie folgt zusammensetzt:

10*10 felde also YYXX YY sind die Y koords, also 01..10 o. 00..09 und XX sind die X koords also .....

Und dann könnteste auch noch das ganze nich im array sondern in einer Verk.Liste machen und die dann halt löschen aber komm... 100 int's fressen nich so viel speicher.