Matrix indizierbar machen?

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

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

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

TGIF

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?

Christian J. schrieb:
> Und die Initialisierung?

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

1

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

2

                                   0,0,1,  //  [0][1][0..2]

3

                                   0,1,0,  //  [0][2][0..2]

4

                                   0,1,0,  //  [1][0][0..2]

5

                                   0,0,1,  //  [1][1][0..2]

6

                                   1,1,1,  //  [1][2][0..2]

7

                                   1,0,0,  //  [2][0][0..2]

8

                                   1,0,1,  //  [2][1][0..2]

9

                                   1,1,0,  //  [2][2][0..2]

10

                                   1,1,1,  //  [3][0][0..2]

11

                                   1,0,0,  //  [3][1][0..2]

12

                                   0,1,0}; //  [3][2][0..2]

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

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

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

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.

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

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.

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?

1

/* Erzeugt eine definierbare Anzahl von Gleitern mit

2

   zufälliger Flugrichtung  */

3

4

static void CreateGliders(uint8_t n)

5

{

6

    static int orientation = 0;

7

8

     static

9

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

10

                                      { {0,1,0}, {0,0,1}, {1,1,1}  },

11

                                      { {1,0,0}, {1,0,1}, {1,1,0}  },

12

                                      { {1,1,1}, {1,0,0}, {0,1,0}}

13

                  };

14

15

  /* Erzeuge n zufällige Positionen und Ausrichtungen */

16

  while (n--) {

17

18

    /* Zufalls Koordinaten-Paar mit 3px Abstand */

19

    int x = 5 + (rand() % (MAX_X-5));

20

    int y = 5 + (rand() % (MAX_Y-5));

21

22

    /* Zufällige Ausrichtung, 0..3 */

23

    //int zufall = rand() % 4;

24

        for (int xp = 0; xp <= 2; xp++)

25

            for (int yp = 0; yp <= 2; yp++)

26

                feld.last[x + xp][y + yp] = glider[orientation][xp][yp];

27

28

        orientation = (orientation + 1) % 4;

29

  };

30

31

}