Trading Card Game ...

[readme.txt]

Halli Hallo, meine Freunde der gepflegten Progammierung ...

Ich brauch mal (was auch sonst) eure Hilfe.

Ich habe mir wiedermal in den Kopf gesetzt eines dieser Projekte anzufangen die
ich meistens nicht beende *g* ... Nichtsdestotrotz lerne ich bei diesen Sachen
immer relativ viel.

Im Speziellen möchte ich mich hier weiter mit Klassen auseinandersetzen. Nicht
der technische Aspekt von Klassen (den habe ich soweit drauf) sondern der logische
Aspekt interessiert mich hier.
Ich habe häufig noch das Problem das ich nicht genau differentieren kann wann eine
Klasse sinn macht und wie man die Klassen am besten Strukturiert, insbesondere was
die Vererbung angeht.

Also habe ich mir jetzt mal das (subjektiv) schwerste Rausgesucht was mir eingefallen
ist: Ein Trading Card Game (TCG) nach dem Vorbild von Magic the Gathering. Es geht nicht
um ein kommerzielles Projekt und ich will das auch nicht Veröffentlichen, darum habe
ich keine großen Gewissensbisse mich bei meinem Vorbild schamlos zu bedienen.

Wer Magic nicht kennt:

Die Spieler haben jeweils ein Set von min. 60 (glaube ich) Karten. Jeder Spieler beginnt
das Spiel mit 20 Lebenspunkten.
Ziel des Spiels ist es nun die Lebenspunkte seines Gegners auf 0 zu reduzieren. Um das zu
erreichen stehen den Spielern diverse Karten und Kartentypen zur Verfügung.

Ein Beispielkartentyp sind z.B. die Kreaturen:



Alle Karten haben folgende Informationen:

• Name: Der Name der Karte, hier: "Ancestor´s Chosen"

• Kosten: Die "Mana"kosten der Karte, hier: 2x Weißes Mana und 5x graues Mana

• Kartentyp: Den Typ der Karte, hier: "Kreatur"

• Kosten: Die "Mana"kosten der Karte, hier: 2x Weißes Mana und 5x graues Mana

• Textfeld: Hier stehen die Fähigkeiten der Karte und manchmal zusätzlich noch ein Zitat

Kreaturen haben noch folgende Informationen:

• Kraturen haben im Feld "Kartentyp" zusätzlich noch die Rasse und/oder Klasse der Kreatur, hier: Mensch, Kleriker

• Kampfwerte: Spezielle Eigenschaft von Kreaturen die die Angriffs/Verteidigungswerte angibt

Als zusätzliches Beispiel nochmal eine Karte vom Typ "Hexerei":



Wie man sieht fehlen diesem Kartentyp einige der Informationen die eine Kreatur besitzt.

...

Um nun aber auch mal auf den Punkt zu kommen:

Mein größtes Problem in der Planung des Spielt ist gleichzeitig das was ein TCG so Faszinierend macht, und zwar die
goldene Regel: Die Karte hat immer Recht

Es ist nicht die Ausnahme sondern die Regel bei solchen Spielen das einzelne Karten das Grundregelwerk erweitern oder
sogar außer Kraft setzen.
Und diese speziellen Kartenregeln gibt es in diversen Variationen.

2 seht ihr oben ja schon:
Die Kreatur hat die Fähigkeit "First Strike" und gibt dem Spieler 1 Lebenspunkt wenn sie ins Spiel kommt.
Mit der Hexere kann ein Spieler einer Kreatur die Fähigkeit "Fliegen" und einen Bonus von +3/+3 auf Angriff/
Verteidigung bis zum Ende seines Zuges geben.

Ein paar andere Beispiele:

Angelic Chorus - Enchantment - Whenever a creature comes into play under your control, you gain life equal to its toughness.

Aura of Silence - Enchantment - Artifact and enchantement spells your opponent play cost 2 mode to play. Sacrifice Aura of Silence: Destroy target artifact or enchantment.

Aven Cloudchaser - Creature, Bird Soldier - Flying. When Aven Cloudchaser comes into play, destroy target enchantment.

Torture - Enchant Creature - Choose target creature: Pay 2 Mana, Put a -1/-1 on creature Torture enchants

Pyroclasm - Sorcery - Pyroclasm deals 2 damage to each creature.

Ambassador Laquatus - Legendary Creature, Merfolk Wizard - Pay 3 Mana: Target Player puts the top three Cards of his or her library into his or her graveyard.

So .. wie ihr vielleich erahnen könnt sind die Fähigkeiten extrem vielfältig. Und genau da liegt mein Problem. Ich hab
keine Idee wie man diese Fähigkeiten Programmiertechnisch umsetzen kann und dabei so flexibel bleibt das man:

1.: Nicht für jede Fähigkeit eine eigene Klasse schreiben muss (das wär Blöd- und Wahnsinn)

und 2.: Das ganze Verhältnissmässig flexibel bleibt so das man nicht das ganze Spiel "neu" bauen muss um eine neue
Fähigkeit einzubauen.


Grundlegend würde ich natürlich eine Klasse "Cards" erstellen und dann Unterklassen wie "Creature", "Enchantment" etc. erstellen die von
"Cards" erben.

Soweit so klar ... nur wie gesagt: Die Fähigkeiten. Das einzige was mir eingefallen ist, ist es irgendwie die Fähigkeiten in mehrere Segmente
zu spalten wie z.B. ZIEL - KOSTEN - WIRKUNG ... die man dann Individuell einstellen kann. Aber das funktioniert ja sogar bei den paar Beispielen oben
nicht immer.

Und selbt wenn, wüsste ich nicht genau wie ich das in Klassen verpacken könnte.

So ... genug geschrieben ... ich hoffe es ist halbwegs klar geworden was mein Problem ist und irgendjemand
der Analytischer als ich denken kann erbarmt sich meiner und hat eine Idee wie man sowas lösen kann.

Danke euch

[ccode]

Ich bin mir nicht sicher ob ich Dich verstanden habe.

Aber ich versuche mal analytich eine gewisse klassenstruktur in form eines xml aufzubauen.

erklädung findest du im xml

PHP-Code:

<root>

   <eigenschaften>
     <lebenskraft/>
     <angriffsstärke/>
     <kosten/>
     <Angriff>
        <Mensch>
            <Normale eigenschaften>
                <treten/>
                <beissen/>
                 .....
            </Normale eigenschaften>
            <Sonder eigenschaften>
                <karte blablub kann gegener fliegend machen/>
                  ......
            </Sonder eigenschaften>
        <gnom>
            ...........
     </Angriff>
     <Abwehr>
         <struktur wie bei Angriff (eins höher), normale und sonder-fälle, du brauchst ja dann nur den Datensatz der Karten für Sondereigenschaft eines Charakters zu bearbeiten und bei neuen Funktionen die Subklassen für Sondereigenschaften nicht Anrühren da diese als interface nur dem aufruf einer generellen klasse "Sonderffunktionen" dienen.>
    </Abwehr>
      
   </eigenschaften>

   <Sonderfunktionen>
      <Angriff/>
      <Abwehr/>
   </Sonderfunktionen>

   <Aktionen>

     <übliche runden aktionen (neuer morgen, neuer lohn)/>
     <übliche spieler aktionen (krankheiten -2, fliegen beenden)/>

     <Angriff>
       <Auf eigenschaften zugreifen/>
       <Auf sondereigenschaften zugreifen/>
     </Angriff>

     <Abwehr>//falls steuerbar
       <Auf eigenschaften zugreifen/>
       <Auf sondereigenschaften zugreifen/>

     </Abwehr>
   </Aktionen>
   <datensätze für spielerkarten und settings einlesen/> 


stellst du dir das ungefähr so vor?

mfg
cc

[readme.txt]

Genau dieser Punkt:

PHP-Code:

<Sonder eigenschaften>
  <karte blablub kann gegener fliegend machen/>
   ......
</Sonder eigenschaften> 


Macht mir solche Kopfschmerzen. Mann muss dazu sagen das es diese Besonderen Fähigkeiten in X Varianten gibt.

Und mir fällt einfach nix ein wie man die schiere Masse dieser Sonderfähigkeiten programmiertechnisch "Fassen" kann und dabei möglichst
dynamisch zu bleiben.

[Omega Psi]

Klassen modellierst du am besten nach den Vorbildern der Karten. Am einfachsten sind natürlich die offensichtlichen Attribute:

package {
 
    public class Card {
 
        private var _abilities:IAbilties;
        private var _cost:ICost;
        private var _type:IType;
 
        public function Card() {
        }
 
        public function get abilities():IAbilties {
            return this._abilities;
        }
 
        public function get cost():ICost {
            return this._cost;
        }
 
        public function get type():IType {
            return this._type;
        }
 
        public function set abilities(abilities:IAbilties):void {
            this._abilities = abilities;
        }
 
        public function set cost(cost:ICost):void {
            this._cost = cost;
        }
 
        public function set type(type:IType):void {
            this._type = type;
        }
 
        public function toString():String {
            var asString:String = "Card";
            asString += "\n\t- abilities: "+this._abilities.toString();
            asString += "\n\t- cost: "+this._cost.toString();
            asString += "\n\t- type: "+this._type.toString();
            return asString;
        }
    }
} 

Warum sind type, abilities und cost keine primitiven Datentypen? Weil sich diese Werte auch aus weiteren Werten zusammensetzen. Als Beispiel ein Interface für die Kosten:

package {
 
    public interface ICost {
 
        public function get greyMana():int;
 
        public function get whiteMana():int;
    }
} 

package {
 
    public class Costs implements ICost {
 
        private var _greyMana:int;
        private var _whiteMana:int;
 
        public function Card(greyMana:int = 0, whiteMana:int = 0) {
            _greyMana = greyMane;
            _whiteMana = whiteMana;
        }
 
        public function get greyMana():int {
            return this._greyMana;
        }
 
        public function get whiteMana():int {
            return this._whiteMana;
        }
    }
} 

Bei den anderen Typen kannst du genauso verfahren. Das Regelwerk bekommt dann 2 Karten und wertet diese aus. Bei Sonderkarten treten dann besondere Regeln ein.

[b.asile]

So zu beginn ist das mal ein riesenklotz,
recht schwer da einen Anfang zu finden.

Ich kenne Magic jetzt nur vom Namen,
habe es selbst noch nie gespielt.
Aber wenn es moeglich ist die ganzen Charakter-Typen,
und deren Eigenschaften fest zu bestimmen dann ist es moeglich
fuer bestimmte Typen Ausnahmen mit einzubeziehen.

Im Prinzip werden ja pro Spielzug nur die Eigenschaften deines Gegners manipuliert.

[querkopf]

Evtl. mußt Du das ganze komplett anders rum angehen. Also nicht von der Karte aus, sondern vom Spieler/dem Spiel ansich aus.

Du formulierst alle Ereignisse eines Spielzugs:
1. Startphase
1.1 Enttappen
1.2 Versorgen
1.3 Ziehen
2. Hauptphase
3. Kampfphase
3.1 Beginn des Kampfes
3.2 ... usw

Und dann alles was betroffen werden kann:
1. Spieler
1.1 Lebenspunkte
1.2 ...
2. Kreatur
2.1 Stärke
2.2 Widerstand
2.3 Fliegen
2.4 Trampeln
2.5 ...
4. Deck
5. Friedhof
6. ... usw

dann kannst Du hinterher in den Karten definieren das zum Ereignis 3.1 Ziel ... verändert werden kann.

Ganz ausgereift ist der Gedankengang noch nicht, aber im Endeffekt definierst Du einmal im Spiel was alles wann verändert werden kann.

Bis dann,
querkopf

p.s.: würde mich freuen das fertige Spiel dann mal testen zu können

[readme.txt]

Ha! ... Wenn mit großem W ... Einen ähnlichen Gedankengang hatte ich auch schon, wobei ich wirklich von der Karte ausgegangen bin. Dein Ansatz ist aber deutlich besser.

Ich hab hier:

http://www.surge-oe.de/stuff/tow/karten.php

zusätzlich noch ein paar Karten hochgeschoben damit ihr mal einen Eindruck bekommt wie vielfältig diese Kartentexte/Fähigkeiten sind.

[bloba]

ohne deiner idee vorwegzugreifen, aber ein spielbare variante von mtg gibt es schon
für alle die es nicht kennen können sich hier infos und das spiel ziehen

ps: hast du keine karten aus der revised oder älteren edition?
ich hab bei ice age aufgehört zu sammeln

[Omega Psi]

Ich würde von der Karte und den Regeln ausgehen. Nicht um gegen Querkopfs Vorschlag anzustinken, sondern da du sowohl in den Regelanwendungen als auch in den zusätzlichen Spielphasen mit den Karten arbeitest. Die Spielphasen sind nur temporäre Zustande des Spieles.

Wichtig wäre für mich zuerst die Karten und Spieler zu modellieren. Danach die Regeln. Wenn gewisse Regeln Anwendung finden, entscheiden die einzelnen Spielphasen, die jedoch nichts anderes als temporäre Zustände des Spieles sind, die sequentiell abgearbeitet werden.

[readme.txt]

@bloba: Ich weiss das es das schon gibt ... Wie oben geschrieben, gerade aufgrund der komplexen Kartenregeln ist das glaube ich eine super Sache um ein bisschen im Bereich strukturierte Programmierung zu lernen, das geht mir immer noch etwas ab. Ich lande immer wieder in blöden Sackgassen weil ich mir die Klassenstrukturen vorher nicht überlegt habe.

@Omega Psi: Ich werd mal sehen das ich eine grundlegende Struktur auf die Reihe bekomme, vielleicht hilft mir das selber auch weiter. Dein Vorschlag von oben ist dabei schon extrem hilfreich ...

danke euch schonmal ... über weiteres Philosophieren freue ich mich aber trotzdem.

Eine halb-Off Topic Sache noch: Wenn ihr sowas plant, wie regelt ihr das? Malt ihr euch da Struktugramme auf mit den Klassen die ihr plant? Oder Scriptet ihr sowas aus dem Bauch/Kopf heraus?

PS: @bloba: Ich hab noch deutlich mehr Karten auf dem Rechner, aber wenn ich die alle hochlade ist mein Webspace voll ^^

[Omega Psi]

Ich arbeite gerne und auch relativ viel mit UML. Es hilft dir ungemein Strukturen zu erarbeiten und vor allen Dingen einen Überblick zu behalten.

Und wenn du kein UML kannst: mach dir einfach Diagramme für Klassen und den allgemeinen Programmfluss.

Mein favourisiertes Tool: Papier und Kuli.

[SpecOps-12]

Ich mach mir mittlerweile öfters vorab einen wohldurchdachten Plan mit ArgoUML.
Dann fang ich an mit dem Code.
Dann schmeiß ich den wohldurchdachten Plan weg und mach einen neuen.
Dann mach ich weiter mit dem Code.
Dann schmeiß ich...

Es wird langsam besser.
Aber das geht mir auch alles furchtbar zäh in den Kopf.
Selbst Skat hab ich schneller gelernt

[_crypto_]

BITTE BLEISTIFFT + RADIERGUMMI!

sosnt verbauchst du zuviel blätter und wir wollen doch nicht
noch mehr unnötig bäume fällen

[Nico B.]

Hi,

wenn Du Hilfe brauchst... Habe mehrere jahre Magic gespielt, sogar auf Turnieren.

Ich würde mich auf die aktuellen Editionen begrenzen, damit die Anzahl der Fähigkeiten im Rahmen bleibt. Ansonsten ist der Berg wohl zu gigantisch. (Was Karten und Fähigkeiten angeht)
Ich würde vom Aufbau her, "einfach" dem Ablauf des Spieles folgen. Sprich Karte ziehen, Länder legen, usw...
Für die Regeln: Erstmal Grundregeln bauen. Später die Sonderfähigkeiten.

lg, nico

Verdammt... jetzt habe ich wieder Lust auf Magic... (Bevor Damage auf den Stack ....)

[Circushund]

hi,

komplexe Sache,
bzgl. Planung:
ich würd auch erstmal einfach anfangen.
Ich persönlich bin eigentlich überhaupt kein Planer in irgend einem Sinne.
Ich hab das zwar auch schon mit Diagrammen versucht, aber ich weiss nicht, mir bringt das irgendwie nicht so viel?
Wärend des Proggens kommen mir dann immer irgendwelche Einfälle und die will ich dann auch noch mit "einarbeiten".
Naja, Im Grunde ist es ja auch schnell gemacht, das man es alle etwas ummodelt, doch manchmal kommt man dann schon an eine Punkt, wo es zu Komplex wird und man einfach "im Sumpf" stecken bleibt und das Handtuch schmeisst .
Eine "grobe" Struktur im Kopf ist aber schon ganz gut,
evtl. so:

1) alles Lernen, Input, Diagramme, Struktur ect...
2) ruhe, rumwandern, vergessen, was anderes machen
3) anfangen