Erstellen bestimmter Klassen Instanzen durch eine Unterklasse in C#

Question

Ich werde meinen spezifischen Anwendungsfall verwenden, um meine Frage zu beschreiben, aber es sollte breiter anwendbar sein, wenn man bedenkt, dass andere Anwendungen eine Unterklasse basierend auf einigen Standardeinstellungen erstellen möchten . Dies ist keine Frage "mach meine Hausaufgaben für mich".

Ich arbeite gerade an einem einfachen Tetris-Spiel, bei dem ich mein Spielfeld als ein zweidimensionales Array mit Bools definiert habe. Ich habe dies in einem Klassenraster getan, um Funktionen hinzuzufügen und meinen Code zu teilen. Ich habe eine Funktion entwickelt, mit der ich überprüfen kann, ob ich an einem bestimmten Ort ein weiteres Gitter hinzufügen kann, um zu überprüfen, ob ein Tetromino an eine bestimmte Stelle verschoben werden kann. (nicht beide Bools an einer Stelle)

Da Tetrominos (auch ein Gitter) in vordefinierten Formen und Größen vorkommen, ist es nur notwendig, jede Form einmal zu erstellen, und dann kann ich meinen aktuellen fallenden Block auf eine Kopie von setzen das vordefinierte tetromino zu manipulieren, wie ich es wünsche.

Jetzt kenne ich zwei Möglichkeiten, diese vordefinierten Formen zu initialisieren: Start in der Haupt-Tetris-Klasse in einem Initialisierer, wo ich ein Raster (Spalten, Zeilen) für jedes Tetromino einmal aufruft und manuell die richtigen Koordinaten auf true oder Erstellen eines zweiten Konstruktors in der Grid - Klasse, der ein char (die Tetromino - Namen L, J, S, Z, T, X, I) verwendet und ein 3x3 - oder 4x4 - Raster mit dem anderen Konstruktor initialisiert, den ich bereits erstellt habe korrigiere die Koordinaten wieder auf wahr.

Beide Methoden hinzufügen Unordnung zu diesen Klassen, die sich hässlich anfühlt. Ich hatte gehofft, dass es möglich wäre, stattdessen eine Unterklasse zu verwenden, wenn man bedenkt, dass die tetriminos technisch eine Art von Gitter sind.

nun der Konstruktor in der Unterklasse für so weit ich nur finden können auf Standardparameter oder Parameter übergeben können, die an die Unterklasse Konstruktor gegeben wurden, etwa so:

class Grid 
{ 
    bool[,] grid; 

    public Grid(int x, int y) 
    { 
     // Creates grid, fills it with bools. 
    } 
} 

class Block : Grid 
{ 
    public Block(char blockShape, int x, int y) : base(x, y) 
    { 
     // Add additional logic here. 
    } 
} 

Jetzt würde mich das erfordern passieren auf die Dimensionen des Tetromino, das sich seltsam anfühlt, wird dies voreingestellt sein. Was ich sehr bevorzugen würde ist etwas in dieser Richtung:

class Block : Grid 
{ 
    public Block(string blockShape) 
    { 
     if ("IX".Contains(blockShape)) 
     { 
      this = new Grid(4, 4); 
      // Add additional logic here. 
     } 
     if ("JLSZT".Contains(blockShape)) 
     { 
      this = new Grid(3, 3); 
      // Add additional logic here. 
     } 
    } 
} 

Ist etwas in dieser Richtung möglich? Wenn ja, wie könnte es getan werden? Wenn nicht, gibt es eine saubere alternative Lösung, die meine Grid- oder Tetris-Klasse nicht stört? Sollte ich etwas anderes machen?

Answer 1

Ich würde einfach statische Readonly-Felder verwenden. Tetrominos sind unveränderlich, Sie müssen sie nur einmal initialisieren und sie so oft verwenden, wie Sie möchten.

Auch ich bin nicht sehr überzeugt von tetrominos abgeleitet von Grid. Für mich sind das konzeptionell sehr unterschiedliche Dinge; Erstere sind voreingestellte unveränderliche Blöcke, letzteres ist das dynamische und sich verändernde Spielfeld. Ich würde diese beiden Elemente überhaupt nicht zusammenführen. Ich würde eine bestimmte Tetromino Klasse erstellen:

public class Tetromino 
{ 
    public static readonly Tetromino J = new Tetromino(new[,] { { false, false, true }, .... }); 
    public static readonly Tetromino L = new Terromino(new[,] { { true, false, false } .... }); 
    //and so on... 

    private readonly bool[,] grid; 
    private Tetromino(bool[,] shape) //disallow any other Terronimos from being built. 
    { 
     this.shape = shape; 
     Width = shape.GetLength(0); 
     Height = shape.GetLength(1); 
    } 

    public int Height { get; } 
    public int Width { get; } 
    public bool this[int row, int col] => shape[row, col]; 
} 

Und jetzt in Ihrer Tetris oder Grid Klasse würden Sie mit Tetromino s arbeiten, ohne die Pflege, welche Form sie wirklich sind. Um einen bestimmten zu spawnen, würden Sie einfach das entsprechende Feld verwenden; myPlayingGrid.Add(Tetromino.J)