Entwicklung eines Kartenspiel-Frameworks

Welche Art von Designmustern und Ideen könnte man verwenden, um ein allgemeines Kartenspiel-Framework zu erstellen?

Dies ist darauf zurückzuführen, dass ich versucht habe, einen Klon des beliebten Steve Jackson-Spiels "Munchkin" zu erstellen. Aufgrund der Natur dieses Spiels musste ich nicht mehr so ​​viele Kartenfunktionen hart codieren, dass die Entwicklung chaotisch und übertrieben wurde. Ich wollte etwas Allgemeines erstellen, hatte aber nur zu viele Klassen mit zu vielen überschriebenen Funktionen und switch-Anweisungen, um das Verhalten zu bestimmen.

Ich war gespannt, was jemand mit mehr Erfahrung im Design für eine solche Aufgabe tun würde, ein Allzweck-Kartenspiel-Framework zu erstellen, oder zumindest etwas, das erweitert werden könnte. Oder ist es am besten, wenn ich ein Kartenspiel wie Munchkin simulieren möchte, stecke ich fest und erstelle ein bestimmtes Framework.

Ich möchte C # verwenden.

BEARBEITEN

Ich möchte etwas klarstellen, was ich irgendwann erreichen möchte. Ich möchte ein Framework, in dem ich grundsätzlich Phasen mit benutzerdefinierten Funktionen implementieren kann (Phase 1: Karten ziehen, Phase 2: Wartungsregeln anwenden, Phase 3: Karten spielen, Phase 4: Auflösen usw.).

Ich denke, dann wäre es klug, einen Regelsatz zu definieren, der sowohl mit den Karten als auch mit den Phasen gekoppelt wäre.

Dann würden die Karten definiert und ich nehme an, dass sie an die Regeln gebunden sind, so dass beispielsweise die Regel "Während der Wartungsphase 1 Token verlieren" lautet. Eine Karte, über die der Spieler verfügt, kann jedoch "Verliere während der Wartungsphase keine Spielmarken" bereitstellen. Es wäre also schön, dies zusammenbinden zu können, aber im Rahmen des Rahmens.

Ich nehme an, das könnte auch ein Ausweg aus meiner Liga sein.

Ich hätte eine Art Skriptsprache wie LUA oder Python verwendet, um jedes spezielle Verhalten oder jede Karte zu definieren.

• http://www.lua.org/
• http://www.python.org/

Auf diese Weise können Sie eine "generische" Engine definieren und die Besonderheiten der Karten vom Hauptcode fernhalten, und zwar in einigen kleinen und leicht bearbeitbaren Skripten.

Der Hauptvorteil von Skriptsprachen gegenüber XML oder anderen "statischen" Daten besteht darin, dass Skriptsprachen mithilfe der von der Engine angebotenen öffentlichen Methoden ihr eigenes Verhalten "erstellen" können.

Beispiel: Angenommen, Ihre Engine bietet die Methoden "setDommage (target, dmg)" und "setVisualEffect (nameOfFxLuaScript)" usw. an. Sie können Karten haben, die so etwas wie diesen Peuso-Code ausführen

------Card1 -- A simple fireball-----
// Fire ball
setDommage(target, 37);
setVisualEffect("fireBall.lua");

------Card2 -- A multitype ball (outch it hurts!)-----
// Fire ball
setDommage(target, 37);
setVisualEffect("fireBall.lua");

// Ice ball
if( player.protectionAgainstIce == false )
{
    setDommage(target, 102);
    setVisualEffect("iceBall.lua");
}

// thunderbolt
while( player.Alive )
{
    setDommage(target, 1005);
    setVisualEffect("thunderBolt.lua");
}

Die beiden Karten verwenden die gleichen Engine-Methoden , aber sie machen nicht die gleichen Dinge. Die Verhaltensweisen können auch Daten verwenden, die von der Engine gesammelt wurden (wie die Spielerliste, um sie zu durchlaufen), und für, wenn usw. Anweisungen.

Der zweite, aber nicht der geringste Vorteil ist, dass es nicht kompiliert werden muss. Sie können Ihr LUA-Skript ändern und direkt neu laden, ohne Ihr Spiel neu zu kompilieren. Es ist sehr schön zum Testen und Iterieren, bis Sie die guten Einstellungen gefunden haben.

Der dritte Vorteil ist, dass jeder, der die Skriptsprache lernen kann, neue Karten / Verhaltensweisen erstellen kann, solange Sie eine Liste der öffentlichen Methoden bereitstellen, die von der Engine gemeinsam genutzt werden (und solange Sie die LUAs nicht codieren). Und wie jeder weiß, ist die Community unglaublich, wenn man ihnen nette Werkzeuge gibt;)

Hier ist ein LUA-Wrapper für C #: http://luaforge.net/projects/luainterface/