OOP Modellierungsfrage

[DagobertDuck]

Guten Tag,

ich bin gerade dabei ein Kartenspiel zu modellieren.

Hier ist ein grober Überblick über die Anforderungen:

Jede Spielkarte kann zu einer der insgesamt drei Kategorie zugeordnet werden:
(i) Ressourcen (resources), (ii) feindliche Tiere (animals), (iii) Katastrophe (catastrophe).

Die insgesamt 64 Spielkarten ergeben sich wie folgt:
• Ressourcen
– 16 × Holz (wood)
– 16 × Metall (metal)
– 16 × Plastik (plastic)
• Tiere
– 5 × Spinne (spider)
– 5 × Schlange (snake)
– 5 × Tiger (tiger)
• Katastrophe
– 1 × Gewitter (thunderstorm)

Zu den Ressourcen zählen, wie oben aufgelistet, Holz (wood), Metall (metal) und Plastik (plastic). Mit einer bestimmten Kombination an Ressourcen ist es möglich, (a) Werkzeuge zu bauen, (b) Bauwerke zu errichten und (c) Rettungen zu initiieren. Im Folgendem werden die Ressourcen- Kombinationen den baubaren Gegenstände zugeordnet.

• Werkzeuge
– Axt (axe): 3 × Metall
– Keule (club) 3 × Holz
• Bauwerke
– Hütte (shack): 2 × Holz, 1 × Metall, 2 × Plastik
– Feuerstelle (fireplace): 3 × Holz, 1 × Metal
• Rettungen
– Segelboot (sailingraft): 4 × Holz, 2 × Metall, 2 × Plastik
– Hanggleiter (hangglider): 2 × Holz, 2 × Metall, 4 × Plastik
– Dampfschiff (steamboat): 6 × Metall, 1 × Plastik
– Heißluftballon (ballon): 1 × Holz, 6 × Plastik

Der Spieler zieht während des Spiels immer die oberste Karten von einem Stapel und kann wie bereits beschrieben Ressourcen sammeln bzw. mit ihnen Gegenstände bauen und auf Tiere treffen, die ihm gesammelte Ressourcen kosten können.

Meine bisherige Lösungsidee

public class PlayingCard {
    public enum Category {
        RESOURCES, ANIMALS, CATASTROPHE;
    }

    private Category category;

    public void setCategory(Category category) {
        this.category = category;
    }

    public Category getCategory() {
        return category;
    }
}

Wie könnte man jetzt die ganzen Materialien modellieren? Macht hier eine Lookup-Tabelle mit einer HashMap Sinn? Ursprünglich hatte ich die Idee eine Oberklasse Resource zu machen und wood, plastic, metal erben dann von der Klasse. Das scheint mir aber keine gute Idee zu sein, da die einzelnen Materialien keine bestimmten Eigenschaften erfüllen müssen und auch keine extra Methoden benötigen.

Könnte mir jemand eine grobe Modellierungsskizze (am besten in Code-Form) geben bzw. meine bisherige Idee bewerten?

Viele Grüße

 

[LimDul]

Mach einen Enum Category. Fast so wie du es gemacht hast, aber als eigenen Enum und nicht als Inner-Enum von PlayingCard würde ich sagen.
Und mach einen Enum CardType (mir fällt kein besserer Name ein), der zu einem ein Feld Category hat und zum anderen aus den Werten Holz, Metall, Plastik, Spinne, etc. besteht.

So würde ich im ersten Schritt ins Rennen gehen.

 

[DagobertDuck]

Danke für die Antwort. Wo soll sich der Enum CardType dann befinden? Auch in einer eigenen Klasse oder in PlayingCard / Category?

EDIT: Ich gehe mal davon aus, dass es auch als eigene Klasse sinnvoll ist. Mir ist allerdings noch nicht klar, wie ich dann eine Kategorie zu den einzelnen Enum Werten zuordnen kann.

Hier meine bisherige CardType Klasse:

public enum CardType {
    WOOD, METAL, PLASTIC, SPIDER, SNAKE, TIGER, THUNDERSTORM;

    private CardCategory category;

    // TODO: Assign each card type to a category
}

 

[LimDul]

Alles eigene Klassen.

public enum CardType {
    
    WOOD(Category.RESOURCES), METAL(Category.RESOURCES), PLASTIC(Category.RESOURCES), SPIDER(Category.ANIMALS), SNAKE(Category.ANIMALS), TIGER(Category.ANIMALS), THUNDERSTORM(Category.CATASTROPHY);

    private final Category category;
    
    private CardType(Category category) {
        this.category = category;
    }
    
    public Category getCategory() {
        return category;
    }
}

 

[temi]

Die Frage ist auch, ob es wirklich notwendig ist, die Karten noch anhand einer Katergorie zu unterscheiden oder ob nicht deine CardType-Enum bereits ausreichend dafür ist.

 

[LimDul]

Der Karte würde ich nur noch eine Variable vom Typ CardType geben - die Kategorie steckt da schon mit drin.

 

[DagobertDuck]

Alles eigene Klassen.

public enum CardType {
   
    WOOD(Category.RESOURCES), METAL(Category.RESOURCES), PLASTIC(Category.RESOURCES), SPIDER(Category.ANIMALS), SNAKE(Category.ANIMALS), TIGER(Category.ANIMALS), THUNDERSTORM(Category.CATASTROPHY);

    private final Category category;
   
    private CardType(Category category) {
        this.category = category;
    }
   
    public Category getCategory() {
        return category;
    }
}

Mir war gar nicht bewusst das man den einzelnen Enum-Werten noch Argumente geben kann. Danke schön!

Die Frage ist auch, ob es wirklich notwendig ist, die Karten noch anhand einer Katergorie zu unterscheiden oder ob nicht deine CardType-Enum bereits ausreichend dafür ist.

Meinst du damit, dass es einen besseren Weg gibt die einzelnen CardTypes in Kategorien zu unterscheiden, oder spielst du darauf an, die Kategorie komplett zu entfernen? Falls ja, die Kategorien werden so gefordert.

 

[temi]

oder spielst du darauf an, die Kategorie komplett zu entfernen

Das hatte ich gemeint. Für die Entscheidung, ob z.B. eine Axt erzeugt werden kann, benötigt man nur die Information 3 x "Holz". Das die Karte "Holz" auch noch in der Kategorie "Resources" ist, interessiert nicht. Es gibt ja nur ein "Holz". Möglicherweise ist es allerdings später irgendwann wichtig, auch das noch zu wissen.

die Kategorien werden so gefordert.

Dann ist das so.