Tetrominos-Spiel in C programmieren

Question

Aufgabe:

Ich soll ein Tetrominos-Spiel in c programmieren. Tetrominos bestehen aus vier quadratischen Blöcken (o l L s _l_), die NICHT umgedreht werden sollen.

Eingabe könnte z.b. wie folgt sein..

4 5
0 0
3 4
2 7
0 3

Man kann hier davon ausgehen, bei der ersten Zahl z.b(4)  geht es um das Tetromino der Sorte 4 (ein o). Bei der zweiten Zahl (5) geht es um die X-Position.

Also ich habe die structs so definiert:

typedef struct tetris{
 int nummer;
 int x;
 int y;
 struct tetris *next;
}tetris;

typedef struct spielfeld{
 int **zeilen;        // muss dynamisch wachsen. Ist das richtig mit den zwei **?
 int spalten = 10;
 tetris **tetr;
}spielfeld

Ansatz/Problem:

Sind die structs so richtig definiert? Wie kann ich jetzt die Y-Position berechnen? Meine Idee, wäre, dass man erst mal schaut, ob der Platz frei ist oder nicht, und dann werden die Tetris da gelegt, wo es Platz gibt.

Ich weiß aber nicht, wie ich das realisieren soll. int y_berechnen (int x);

Answer 1

Antwort mit KI erzeugt

Strukturanalyse und Definitionen

Deine grundlegenden Struktur-Definitionen für das Tetris-Spiel in C sind ein guter Startpunkt, aber es gibt einige Punkte, die korrigiert oder weiterentwickelt werden sollten:

- Für spielfeld musst du die Definition von Attributen außerhalb von Funktionen vermeiden. Die Initialisierung von int spalten = 10; direkt in der Strukturdefinition ist in Standard-C nicht zulässig. Stattdessen kannst du dies im Konstruktor oder in einer Initialisierungsfunktion für deine Spielfeldstruktur tun.

- Da zeilen als ein Zeiger auf einen Zeiger definiert ist, ist dies korrekt für eine dynamische 2D-Array-Allokation, die benötigt wird, um ein variabel großes Spielfeld zu repräsentieren.

- Die Verwendung von tetris **tetr; innerhalb der spielfeld-Struktur könnte je nach deinem genauen Implementierungsplan variieren. Wenn du planst, eine dynamische Liste aller platzierten Tetrominos zu führen, könnte dies funktionieren, aber die genaue Nutzung und Notwendigkeit dieser Komponente sollte weiter definiert werden.

Y-Positions-Berechnung

Die Idee, zu überprüfen, ob Platz verfügbar ist, bevor ein Tetromino platziert wird, ist sinnvoll. Die Implementierung dieser Logik erfordert ein sorgfältiges Design. Hier ist ein grundlegender Ansatz:

1. Überprüfe die Verfügbarkeit: Um zu überprüfen, ob für ein bestimmtes Tetromino an einer spezifischen X-Position (und der daraus resultierenden Y-Position) Platz verfügbar ist, musst du das Spielfeld an den entsprechenden Positionen überprüfen.

2. Y-Positionierung: Die Y-Position könnte so berechnet werden, dass das Tetromino so weit wie möglich nach unten fällt, ohne dass es ein anderes Tetromino oder den Boden des Spielfelds überschreitet.

Die grundlegende Funktion, um die Y-Position zu berechnen, könnte so aussehen:

c
int berechne_Y_Position(spielfeld *feld, int tetrominoTyp, int xPosition) {
    // Annahme: Das Spielfeld hat eine Höhe, die bekannt ist oder abgefragt werden kann
    int maxY = feld->zeilenHoehe; // Angenommen, du hast eine Variable, die die Höhe speichert.
    for (int y = 0; y < maxY; y++) {
        if (!istPlatzFrei(feld, tetrominoTyp, xPosition, y)) {
            return y - 1; // Das Tetromino sollte oberhalb der aktuellen, gefüllten Position platziert werden.
        }
    }
    return maxY - 1; // Wenn es bis zum Boden kommt, wird es am unteren Rand platziert.
}

Die Funktion istPlatzFrei müsste die Logik enthalten, um zu überprüfen, ob alle benötigten Positionen für das Tetromino frei sind. Dies setzt voraus, dass du bereits eine Repräsentation des Spielfelds hast, in der gefüllte Positionen irgendwie markiert sind, z.B. mit einem Wert ungleich Null.

Wichtiger Hinweis: Die obigen Codebeispiele gehen von bestimmten Annahmen aus und dienen lediglich als Anhaltspunkte. Für ein vollständiges Tetris-Spiel ist eine weit umfassendere Implementierung mit detaillierter Logik für das Platzieren von Tetrominos, das Löschen voller Linien etc. erforderlich. Es ist auch wichtig, die dynamische Speicherverwaltung für die zeilen im spielfeld-Struktur sorgfältig zu handhaben, um Speicherlecks zu vermeiden.