# Kartenspiel Leben und Tod programmieren



## br3nn3r (4. Jan 2011)

Also wir sollen folgendes Spiel programmieren:

Die allgemeinen Spielregeln:
Hierbei handelt es sich um eine ganz einfache Variante des Spiels "Leben und Tod". Das
Spiel wird mit zwei Spielern gespielt. Jeder der Spieler erhält einen Kartenstapel, indem ein
Kartenspiel ausgeteilt wird. Von diesen Stapeln wird jeweils die oberste Karte gezogen und
mit der Karte des Gegners verglichen. Der Spieler mit der höheren Karte erhält beide Karten,
die er auf einen Ablagestapel legt. Die Reihenfolge der Karten ist: 7, 8, 9, 10, B, D, K, As. Bei
gleichem Wert entscheidet die Farbe, hier gilt: Karo, Herz, Pik, Kreuz. Ist ein Kartenstapel zu
Ende, wird mit dem Ablagestapel weitergespielt. Das Spiel ist nach einer festgelegten Anzahl
von Runden (oder wenn ein Spieler keine Karten mehr hat) zu Ende. Gewonnen hat der
Spieler, der am Ende mehr Karten besitzt.

Die Realisierung am Computer:
Es spielen Computer und Spieler gegeneinander. Es gibt keine Strategie, sondern das Spiel
läuft nach dem Geben der Karten voll deterministisch ab. Deshalb kann per
Computerprogramm schnell entschieden werden, wer das Spiel gewinnt. Damit Sie trotzdem
den Spielverlauf verfolgen können, sollte eine geeignete Ausgabe erfolgen (z.B. jeweils die
beiden gezogenen Karten) und jeder Spielzug mittels Drücken der Enter-Taste so verzögert
werden, dass am Bildschirm der Spielverlauf nachvollzogen werden kann.

Hab mich schon ein wenig umgeschaut und bin jetzt soweit das ich den Kartenstapel und das Mischen hinbekommen habe das sieht bei mir folgendermaßen aus:


```
class Karte
{
	// Bewertung der Karten und Definition der Farben
   public final static int KARO  = 0, HERZ  = 1, PIK   = 2, KREUZ = 3;                            
   public final static int BUBE = 11, DAME = 12, KOENIG = 13, ASS = 1;
   private final int farbe, wert;  
                            
   // Konstruktor                          
   public Karte(int f, int w)
   {
      farbe = f;
      wert 	= w;
   }
        
   // get-set-Funktionen
   public int getFarbe()
   {
      return farbe;
   }
    
   public int getWert()
   {
      return wert;
   }
    
   // Karten-Methoden
   public String Farbe2String()
   {
      switch (farbe) {
         case KARO:   
         	return "Karo";
         case HERZ:   
         	return "Herz";
         case PIK: 
         	return "Pik";
         case KREUZ:    
         	return "Kreuz";         	
      }
      System.out.println("Farbe falsch! : "+farbe);
      return "-1";
   }
    
   public String Wert2String()
   {
   	if ((wert>=2)&&(wert<=10))
   		return ""+wert;
   		
      switch (wert) {
         case 1:   
          	return "A";
         case 11:  
         	return "B";
         case 12:  
         	return "D";
         case 13:  
         	return "K";
        }
      return "-1";     
   }
    
   public String Karte2String() 
   {
      return Farbe2String() + "-" + Wert2String();
   }
}

public class Kartenspiel
{
   // 32er Kartenstapel (7-10,B,D,K,A für Karo, Herz, Pik und Kreuz)
   private Karte[] stapel;   
   private int kartenImSpiel; 
    
   // Konstruktor
   public Kartenspiel() 
   {
      stapel = new Karte[32];
      int zaehler = 0;
      for (int f=0; f<4; f++ ) 
      {
         for (int w=1; w<7; w++ ) 
         {
            stapel[zaehler] = new Karte(f, w);
            zaehler++;
         }
      }
      mischen();
   }
    
   // KartenSpiel-Methoden
   public void mischen()
   {
      Karte temp;
      for (int i=31; i>0; i--)
      {
         int zuff       = (int)(Math.random()*(i+1));
         temp           = stapel[i];
         stapel[i]      = stapel[zuff];
         stapel[zuff]   = temp;
      }
      kartenImSpiel = 32;
   }
    
   public int kartenAnzahl()
   {
      return kartenImSpiel;
   }
    
   public Karte gibEineKarte()
   {
      if (kartenImSpiel == 0)
         mischen();         
      kartenImSpiel--;
      return stapel[kartenImSpiel];
    }
}
```

kann man das soweit machen?
meine Frage ist jetzt wie schaff ich jetzt das die gemischten karten in zwei stapel aufgeteilt werden? damit ich sie dann miteinander vergleichen kann?

danke schonmal


----------



## darekkay (4. Jan 2011)

Wenn du deinen stapel[] gefüllt/gemischt hast, dann kannst du doch zwei neue arrays erstellen stapel1[] und stapel2[] und weist denen jeweils die Hälfte vom stapel[]-Array zu 

Übrigens, ein schönes, einfaches Spiel (aber leider mit 100% Glück ^^) - wir hatten als Kinder immer eine Regel, die das ganze "spannender" gemacht hat - bei gleichen Karten wird eine Karte verdeckt gelegt, dann wieder eine offen, und dann bekommt der Sieger alles. (bzw. bei erneut gleichen Karten das ganze wiederholen).
So konnte man auch unter Umständen auch ein Ass bekommen (bei dir klappt es auch nur für 3 Asse, da man den höchsten niemals gewinnen kann).
So gesehen gewinnt bei dir IMMER der Spieler, der das Kreuz-Ass hat. Die Karte kann er schließlich niemals verlieren


----------



## lightblue (6. Jan 2011)

hi,
hat jemand eine komplette lösung wie man das kartenspiel leben und tod mit java programmiert?
komm da echt nimmer weiter....!!!!
brauch ganz dringend eine musterlösung!!!!!
vielen vielen dank


----------



## VfL_Freak (6. Jan 2011)

Moin,

wohl eher nicht 

Zeig doch mal, was Du bislang als Ansatz hast und stell' dann dazu konkrete Fragen 
Dann wird Dir hier auch gerne geholfen 

Gruß
Klaus


----------



## br3nn3r (7. Jan 2011)

könntest du mir zeigen wie genau ich das mit dem zuweisen mache? also meinen stapel in die zwei neuen arrays aufteile?


----------



## darekkay (7. Jan 2011)

```
for(int i = 0; i < 25; i++)
stapel1[i] = stapel[i]
for(int i = 25; i < 51; i++)
stapel2[i-25] = stapel[i]
```

sowas in der Art


----------



## br3nn3r (8. Jan 2011)

sry aber irgendwie klappt das net so wie ich das will ... diese for schleife müsste ich doch in zeile 85 einbauen oder?

wenn ich dann aber in der main funktion mir den wert des stapels anzeigen lasssen will dann kommt da immer der wert null.


----------



## br3nn3r (9. Jan 2011)

hab das jetzt nochmal ganz anders angefangen

bis jetzt hab ich folgenden code:


```
public class Kartenspiel 
{
	public static void main (String[] args)
	{
	Stack myList = new Stack (32);
	if (!myList.isFull())
	{
		myList.push(new Karte("Harry Potter", "Rowling"));
	}
	if (!myList.isFull())
	{
		myList.push(new Karte("Harry Potter", "Rowling"));
	}
	if (!myList.isEmpty())
	{
		Karte element = myList.pop();
		System.out.print("Jetzt lese ich:");
		element.print();
	}
	}
}
class Karte
{
	private String ziffer;
	private String farbe;
	public Karte (String ziffer, String farbe)
	{
		this.ziffer = ziffer;
		this.farbe = farbe;
	}
	public void print ()
	{
		System.out.println(ziffer + " von " + farbe);
	}
}

class Stack
{
	{
	while (!kartenStapel.isFull())
    {
        kartenStapel.push(new Karte(ziffer[i], farbe[j]));
    }
	
	spielerStapel = new Stack (kartenStapel/2); //solange Karten geben bis voll
	computerStapel = new Stack (kartenStapel/2); //solange Karten geben bis voll
	
	 private Karte[] array;
	 private int top = 0;
	 public Stack(int nr)
	 {
		 array = new Karte[nr];
	 }
	 	 
	 public void push (Karte element)
	 {
		 array[top++] = element;
	 }
	 
	 public Karte pop()
	 {
		 return array[--top];
	 }
	 
	 public boolean isEmpty()
	 {
		 if (top == 0)
		 {
			 return true;
		 }
		 else
		 {
			 return false;
		 }
	 }
	 public boolean isFull()
	 {
		 if(top == array.length)
		 {
			 return true;
		 }
		 else
		 {
			 return false;
		 }
	 }
}
	
class Spiel
{
	public Spiel()
	{
		Karte elementSpieler = spielerStapel.pop();
		System.out.print("Karte des Spielers:");
		elementSpieler.print();

		Karte elementComputer = computerStapel.pop();
		System.out.print("Karte des Computers:");
		elementComputer.print();
	}
	public void Gewinn()
	{	
		if (ziffer.elementSpieler > ziffer.elementComputer)
		{
			gewinnStapelSpieler.push(elementComputer)
		}
		else if (ziffer.elementSpieler == ziffer.elementComputer)
		{
			farbe.elementSpieler == farbe.elementComputer
		}
		else if (ziffer.elementSpieler < ziffer.elementComputer)
		{
			gewinnStapelComputer.push
		}
	}
}
```

hab das aus ner übungsaufgabe übernommen deshalb steht oben noch buch usw drin.

komm jetzt aber irgendwie nimmer weiter, wäre über jede hilfe dankbar

grüße


----------



## MrChT (9. Jan 2011)

Hey,

ich programmiere gerade am gleichen Spiel und hätte eine Frage dazu.
Ich hatte den Kartenstapel als Stack gebastelt und mit 32 Integer-Variablen (mit Math.random()) gefüllt.

Mein Problem:
Math.random() gibt mehrmals die gleichen Werte aus.
Mein "Wunschzettel":
Eine Art Stack, welches vor dem befüllen überprüft, ob ein Wert bereits im Stack vorhanden ist. In etwa so wie ein TreeSet, nur, dass die Werte zufällig nacheinander eingefügt, und NICHT sortiert wieder ausgegeben werden.

Kann mir jemand helfen?

Freundlichste Grüße


----------



## Network (9. Jan 2011)

@Threadstarter: Mit was kommst du jetzt nicht mehr weiter?



MrChT hat gesagt.:


> Hey,
> 
> ich programmiere gerade am gleichen Spiel und hätte eine Frage dazu.
> Ich hatte den Kartenstapel als Stack gebastelt und mit 32 Integer-Variablen (mit Math.random()) gefüllt.
> ...



Wie währe es mit einer ArrayList, gefüllt mit deinen gewünschten Zahlen. 
Math.random() wählt eine Zahl von 0 bis (ArrayList.size()-1)
Du nimmst die Zahl heraus und removest dann den Eintrag...


----------



## Quaxli (10. Jan 2011)

MrChT hat gesagt.:


> Hey,
> 
> ich programmiere gerade am gleichen Spiel und hätte eine Frage dazu.
> ...



Dann mach' einen eigenen Thread auf.


----------



## Ivan Dolvich (20. Jan 2011)

Hi Brenner,

ich kann gerade nicht schlafen. Dein Glück, ich versuch dir mal bisschen weiter zu helfen. (Übrigends sollte dieser Thread unter Hausaufgaben laufen, aber was solls..)
Vorweg, ich kenne das Spiel nicht, aber wenn ich es richtig verstanden habe, gibt es zwei Spieler, jeder bekommt die hälfte der Karten, in jeder Runde wird von jedem Spieler eine Karte gezeigt, und der mit der höheren Karte bekommt beide und legt sie weg.

Was brauchen wir?
Karten
Kartenstapel
Spieler
und irgendwas, in dem alles drin steckt.

Fangen wir mit der *Karte* an:
Eine Karte hat einen Wert. z.B. 5 oder 7 oder Bube.
Eine Karte hat eine Farbe. z.B. Herz, Karro oder Kreuz.
Man muss erst den Wert, und wenn dieser gleich ist, dann die Zahl mit einer anderen Karte vergleichen.
Zahlen kann man gut vergleichen. Zum Beispiel ist die 7 größer wie 5 und der Bube? Naja, machen wir ne Zahl draus. Bube enspricht 11, Dame der 12, usw. Für die Farbe das selbe. Karo := 0, Herz := 1, usw.
Schon kann man Karten vergleichen. Bei dir hattest du Strings benutzt. Damit könnte man es irgendwie auch hinbekommen, aber... naja.

Wenn man die Karten hat, dann ist der *Stapel* recht einfach.
Er hat eine Liste von Karten.
Er kann mischen, Karten weggeben und Karten aufnehmen
Dein Stack kann das schon ganz gut. Nur die Zeilen 39 - 46 machen keinen Sinn... Hast du mal versucht, das zum laufen zu bringen?
Ich würde dir aber Listen empfehlen.

Der *Spieler* ist noch einfacher. Er besteht aus zwei Stapeln. Ein Stapel für die Karten auf der Hand, ein Stapel für die gewonnen Karten.
Er muss die oberste Karte zeigen  und wenn er verloren hergeben können oder die Karte vom Gegner nehmen können.

Und dieses *irgendwas, in dem alles drin steckt*... naja, das kommt automatisch.

Also meine Skizze von den Klassen sähe so aus:

```
class Karte{
  int wert;
  int farbe;
}

class Stapel{
  ArrayList<Karte> karten = new ArrayList<Karte>();
  void mischen();
  void push(Karte);
  Karte pop();
  boolean istLeer();
  int getAnzahl();
}

class Spieler{
  Stapel karten;
  Stapel gewonneneKarten;
  Karte zeigeKarte();
  void gewonnen(Karte);
}

class Spiel{
  Spieler mensch;
  Spieler computer;

  void vorbereiten();
  void spiele();
  boolean istSpielZuEnde();
}
```

So. Die Skizze ist eigentlich schon fast ein Geschenk. Du musst sie nurnoch ausmahlen.
Geh Schritt für Schritt vor.
Erst die Klasse Karte. Was braucht die noch? Nur noch Getter und Setter => Java Bean

Klasse Stapel:
Die Klasse Collections aus dem Package java.util hat die Methode shuffle(List<T>). Damit kannst du deine Karten mischen.
Die anderen beiden Methoden bekommst du auch hin. Spätestens steht in dem Link zu den Listen von oben alles drin.

Klasse Spieler:
Auch nichts tolles. Das bekommst du auch hin.

Klasse Spiel wird minimal schwieriger:
in der Methode vorbereiten machst du alles, was du brauchst, um ein Spiel starten zu können. Du erstellst die Karten, die Spieler und die Stapel.
in spiele() wird eine runde berechnet.
Dabei werden die obersten karten gezogen und... naja, steht alles schon in deiner Beschreibung. Einfach eins nach dem anderen umsetzen.
die Methode istSpielZuEnde() überprüft, ob die jeweiligen Ereignisse eingetroffen sind, damit ein spiel zuende ist.


Was du jetzt noch brauchst, ist eine main-Methode, die das Spiel zum laufen bringt, und solang am laufen hält, bis Spiel.istSpielZuEnde() == true

Viel erfolg!
Ivan


----------

