Matrix indizierbar machen?

[Christian J. (Gast)]

Hallo,

ist etwas schwierig mit der Rubrik, da es einfach nur ein "C" Thema ist. 
Bei meiner "Game of Live" Simulation möchte ich sog. Gleiter erzeugen 
und zwar in allen 4 Richtungen.

Das Dumme ist nur, dass ich statt glider0 etc. gern da auch einen Index 
hätte. Es sind hier nur 4, könnten aber auch 100 sein.

Geht da in C etwas in der Richtung? Und zwar MIT Einstellung der Werte?
Ein typeof struct ist mir wohl bekannt aber nicht wie ich da Werte 
voreinstelle.

Vorschweben würde mir sowas wie orientation[0..3].glider[x][y] aber das 
ist nur eine Idee

  static   /* Bytemuster eines Gleiters in allen 4 Richtungen */ 
  const uint8_t glider0[3][3] = {  1,1,1,  //  [0][0..2]
                                   0,0,1,  //  [1][0..2]
                                   0,1,0};  //  [2][0..2]

  const uint8_t glider1[3][3] = {  0,1,0,  //  [0][0..2]
                                   0,0,1,  //  [1][0..2]
                                   1,1,1};  //  [2][0..2]

  const uint8_t glider2[3][3] = {  1,0,0  //  [0][0..2]
                                   1,0,1,  //  [1][0..2]
                                   1,1,0};  //  [2][0..2]

  const uint8_t glider3[3][3] = {  1,1,1,  //  [0][0..2]
                                   1,0,0,  //  [1][0..2]
                                   0,1,0};  //  [2][0..2]

[Matthias (Gast)]

Warum nicht einfach uint8_t glider[XX][3][3]?

[Christian J. (Gast)]

Matthias schrieb:
> Warum nicht einfach uint8_t glider[XX][3][3]?

Tja, warum eigentlich nicht......  (ups!) Und die Initialisierung?

[Matthias (Gast)]

TGIF

[Egon D. (Gast)]

Christian J. schrieb:

> Das Dumme ist nur, dass ich statt glider0 etc. gern da
> auch einen Index hätte. Es sind hier nur 4, könnten aber
> auch 100 sein.

Hmm.
Und wozu braucht man so etwas?

Also präziser: Wozu braucht man Hunderte kleine Feldchen,
in denen jeweils dasselbe (bzw. eins von vier) Bitmuster(n)
abgespeichert ist?

[HildeK (Gast)]

Christian J. schrieb:
> Und die Initialisierung?

Ich hätte mal gesagt: einfach weiter so, wie in deinem Code mit 2 
Dimensionen schon begonnen:

  const uint8_t glider{3][3][3] = {1,1,1,  //  [0][0][0..2]
                                   0,0,1,  //  [0][1][0..2]
                                   0,1,0,  //  [0][2][0..2]
                                   0,1,0,  //  [1][0][0..2]
                                   0,0,1,  //  [1][1][0..2]
                                   1,1,1,  //  [1][2][0..2]
                                   1,0,0,  //  [2][0][0..2]
                                   1,0,1,  //  [2][1][0..2]
                                   1,1,0,  //  [2][2][0..2]
                                   1,1,1,  //  [3][0][0..2]
                                   1,0,0,  //  [3][1][0..2]
                                   0,1,0}; //  [3][2][0..2]

(Ich bin in C aber nicht verlässlich :-) )

[HildeK (Gast)]

Falsche Klammer ...
const uint8_t glider{3][3][3]
                    ^

[Christian J. (Gast)]

Egon D. schrieb:
> Wozu braucht man Hunderte kleine Feldchen,
> in denen jeweils dasselbe (bzw. eins von vier) Bitmuster(n)
> abgespeichert ist?

Nur als Beispiel, braucht man nicht.

[Eric B. (beric)]

"Conway's Game of LiFe", mit F, bitte.

Wozu brauchst du die 100e Muster? Einfach das Spielfeld willkürlich 
initialisieren und die Simulation laufen lassen. Dann entstehen die 
Glider (und andere Muster) von alleine.

[Christian J. (Gast)]

Eric B. schrieb:
> Dann entstehen die
> Glider (und andere Muster) von alleine.

Ah ja... und irgendwann hören sie auf. Nicht gut für ein "Wand-Bild", 
was ständig laufen soll.

https://www.youtube.com/watch?v=WSc9vmUSVzU

Ein Glider Kanone wird übrigens nie zufällig entstehen, das sind alle 
"erforschte Muster", von allein entstehen nur Stillleben, Blinker und 
Gider, sowie einige sternförmige Pulsare, die sich aufblasen und dann 
wieder "verglühen". Es bleiben immer so ein Gekrümel übrig und Zeugs was 
blinkt.

Um optisch was zu erzeugen muss man schon deren Startmuster abspeichern 
und einspielen!

Die Gleiter erzeuge ich künstlich in allen 4 Flug-Richtungen und schieße 
sie ins Feld, 3 Stück, je 90 Grad gedreht, damit ihre Kollisionen neue 
Muster erzeugen. Den Fall 3 parallel fliegende Gleiter zu haben, die 
niemals kollidieren hatte ich schon bei dem kleinen Feld.

[Eric B. (beric)]

Christian J. schrieb:
> Ah ja... und irgendwann hören sie auf. Nicht gut für ein "Wand-Bild",
> was ständig laufen soll.

Dass du diese Bedingung in deinem Eingangspost nicht erwähnst, kannst du 
mir nicht vorwerfen ;-)

Dein Code hat jetzt doch schon die 4 Glider als indizierbare Muster da; 
was ist denn genau das Problem? Mehrere Muster unterschiedlicher Größe?

EDITH: Das verlinkte Youtube Video hat sogar einen Link auf den 
Source-Code!

[Christian J. (Gast)]

Eric B. schrieb:
> Dein Code hat jetzt doch schon die 4 Glider als indizierbare Muster da;
> was ist denn genau das Problem? Mehrere Muster unterschiedlicher Größe?

Alles ist gut. Du hast sehr spät auf den Beitrag reagiert. Wollte aber 
antworten. Und das Video ist ja von mir.... mit dem Code :-)

[Wolfgang (Gast)]

Christian J. schrieb:
> Ah ja... und irgendwann hören sie auf. Nicht gut für ein "Wand-Bild",
> was ständig laufen soll.

Um das zu vermeiden, hat man schon in den späten 70er Jahren des vorigen 
Jahrhunderts angefangen, ab und zu zufällig ein paar Pixel einzustreuen.
Das wirkt stationären Endzuständen entgegen.

[Wolfgang (Gast)]

p.s.

Christian J. schrieb:
> Youtube-Video "[Elektronik] Conway's "Game of Life" on STM32F103 "Blue
> Pill""

Zähl mal die LEDs deiner Matrix nach ;-)
24 * 32 ≠ 512

[micha (Gast)]

Wieso machst du nicht eine Initalisierungsfunktion "AddGlider(x,y, 
direction)", die einen Glider in entsprechende Stelle der Matrix 
kopiert. Dann kannst du eine entsprechenden x,y,direction in einem Array 
speichern\ initialisieren.

[Christian J. (Gast)]

micha schrieb:
> Wieso machst du nicht eine Initalisierungsfunktion "AddGlider(x,y,
> direction)", die einen Glider in entsprechende Stelle der Matrix
> kopiert.

Schonmal in die tools.c oben geschaut?

/* Erzeugt eine definierbare Anzahl von Gleitern mit
   zufälliger Flugrichtung  */

static void CreateGliders(uint8_t n)
{
    static int orientation = 0;

     static
    const uint8_t glider[4][3][3] = { { {1,1,1}, {0,0,1}, {0,1,0}  },
                                      { {0,1,0}, {0,0,1}, {1,1,1}  },
                                      { {1,0,0}, {1,0,1}, {1,1,0}  },
                                      { {1,1,1}, {1,0,0}, {0,1,0}}
                  };

  /* Erzeuge n zufällige Positionen und Ausrichtungen */
  while (n--) {

    /* Zufalls Koordinaten-Paar mit 3px Abstand */
    int x = 5 + (rand() % (MAX_X-5));
    int y = 5 + (rand() % (MAX_Y-5));

    /* Zufällige Ausrichtung, 0..3 */
    //int zufall = rand() % 4;
        for (int xp = 0; xp <= 2; xp++)
            for (int yp = 0; yp <= 2; yp++)
                feld.last[x + xp][y + yp] = glider[orientation][xp][yp];

        orientation = (orientation + 1) % 4;
  };

}