4. Speicherplätze von Arrays "sperren"

Speicherplätze von Arrays "sperren"

  • ?

    moin. Ich programmiere zurzeit ein Memory spiel und steuere die karten an sich verständlicher weise mit 2D Arrays.

    jetzt bin ich gerade an der stelle, dass die richtigen gewählten karten nicht mehr angezeigt werden sollen.

    da ich aber ne Forschleife habe die sich immer wiederholt quasi die karten "umdreht" und es viel zu umständlich wäre mit zich if schleifen zu sagen er solle nichts ausgeben, hab ich mich gefragt ob man vlt bestimmte arrays sperren kann

    zb dass array[3][4] jetzt gezogen wurd eund nicht mehr auftauchen soll. Quasi den wert unveränderlich auf 0 setze (dass die forschleife keine wirkung drauf hat)

    also das wäre mir eine riesige hilfe 🙂 ich hoffe ihr könnt mir helfen. Danke im vorraus!

    0
  • T

    Ich nehme mal an, dass Du die verschiedenen Karten irgendwie mit Zahlen repräsentierst, Du könntest dann einfach eine Zahl nehmen, die zur Zeit nicht in der Menge an Karten vorkommt und bereits umgedrehte Karten auf diesen Wert setzen.
    Dann kannst Du so abfragen ob was zu tun ist, oder nicht.

    #define GEFUNDEN (-1)

    //...code...

    if(array[x][y] != GEFUNDEN)
    {
        //mache was
    }
    0
  • ?

    yus schrieb:

    moin. Ich programmiere zurzeit ein Memory spiel und steuere die karten an sich verständlicher weise mit 2D Arrays.

    Nein, ist mir unverständlich. Warum nicht 1D oder noch besser als Liste?

    yus schrieb:

    jetzt bin ich gerade an der stelle, dass die richtigen gewählten karten nicht mehr angezeigt werden sollen.
    da ich aber ne Forschleife habe die sich immer wiederholt quasi die karten "umdreht" und es viel zu umständlich wäre mit zich if schleifen zu sagen er solle nichts ausgeben, hab ich mich gefragt ob man vlt bestimmte arrays sperren kann
    zb dass array[3][4] jetzt gezogen wurd eund nicht mehr auftauchen soll. Quasi den wert unveränderlich auf 0 setze (dass die forschleife keine wirkung drauf hat)
    also das wäre mir eine riesige hilfe 🙂 ich hoffe ihr könnt mir helfen. Danke im v******!

    Mit ner Liste hättest du so ein Problem nicht. Lass die Liste einfach um jedes aufgedeckte Paar schrumpfen, dann entfallen auch die vielen überflüssigen Abfragen in der for Schleife.
    🙂

    0
  • ?

    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.

    0
  • B

    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...

    0
  • T
     

    #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 */
        }
    }
}
    0
  • B
     

    /*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"

    0
  • ?

    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. 🙄

    0
  • T

    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.

    0
  • ?

    Tachyon schrieb:

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

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

    0
  • ?

    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

    0
  • ?

    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 !!!

    0
  • L

    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.

    0
Anmelden zum Antworten