# Kartenspiel



## vensch (10. Mai 2009)

Hallo Leute, ich bin gerade dabei, den Code für ein Kartenspiel zu schreiben und komme an zwei Stellen nicht weiter - bei der Methode _createPlayer_ und _getBestCard_.

Hier die Klasse Player:


```
import javax.swing.JOptionPane;

/**
 * Diese Klasse stellt den Spieler des Spiels dar. Er besitzt einen Namen und
 * ein Menge von Karten.
 * 
 * @author
 * 
 */
public class Player {
	private final String name;

	private Card[] cards;

	/**
	 * Der Konstruktor setzt den Namen des Spielers und initialisiert das Array
	 * cards mit der Maximalanzahl der Karten
	 * 
	 * @param name
	 * @param maxCards
	 */
	public Player(String name, int maxCards) {
		this.name = name;
		this.cards = new Card[maxCards];
	}

	/**
	 * Diese Standardmethode liefert den Namen des Spielers
	 * 
	 * @return
	 */
	public String getName() {
		return name;
	}



	/**
	 * Diese statische Methode erstellt den Spieler mit der Nummer index+1. Der
	 * index liegt bei 4 Spieler zwischen 0 und 3, wie bei den index des Arrays.
	 * Dafür soll ein Name eingegeben werden. Anschließend wird ein Objekt der
	 * Klasse Player erzeugt und zurückgegeben. Falls kein Name eingegeben
	 * wurde, soll "null" zurückgegeben werden.
	 * 
	 * @param index
	 * @return
	 */
	public static Player createPlayer(int index) {
		/*
		 * Code
		 */
		return null;
	}
	/**
	 * Diese Methode liefert die beste Karte, welche der Spieler auf der Hand hat. 
	 * Die Karten sind dabei folgendermaßen bewertet:
	 * Karo_7,Karo_8,...,Karo_Ass,Herz_7,...,Herz_Ass,Pik_7,...,Pik_Ass,Kreuz_7,...,Kreuz_Ass.
	 * Demnach ist Kreuz_Ass die beste Karte überhaupt. Aber welche ist die Beste, die der Spieler
	 * auf der Hand hat? Wenn der Spieler keine Karten auf der Hand hat, wird null zurückgegeben.
	 * @return
	 */
	public Card getBestCard() {

		/*
		 * Code
		 */
		return null;
	}
}
```

Wäre über Hilfe sehr dankbar!


----------



## Lexi (10. Mai 2009)

Es wäre hilfreich, wenn du auch noch die Klasse Card posten könntest.

Wenn wir davon ausgehen das Karo_7,Karo_8,Karo_9 ... Konstanten sind ( wenn auch mit unkonventionellen Namen ) , die alle durchnummeriert sind ( kleinste Karte = 1 bis größte Karte = 32 ( bei 32 Karten insg. ), dann musst du einfach nur noch das Array durchlaufen in dem die Karten eines jeden Spielers gespeichert sind und die mit dem höchsten Wert zurückgeben.
Am einfachsten ist es, denke ich, wenn du dir eine lokale Variable z.B. highestCard vor der Schleife erstellst, die in der Schleife dann auf card_ gesetzt wird, sobald cards.getValue() > highestCard ist. Am Ende musst du dann nur noch highestCard returnen._


----------



## vensch (10. Mai 2009)

Oh ja, das wäre vermutlich wirklich hilfreich 


```
public class Card {

	private final SkinOfCard skin;
	private final ColorOfCard color;
	/**
	 * Privater Konstruktor, welcher die Eigenschaften der Karte festlegt
	 * @param skin
	 * @param color
	 */
	private Card(SkinOfCard skin, ColorOfCard color) {
		this.skin = skin;
		this.color = color;
	}
	/**
	 * Liefert den Wert der Karte
	 * @return
	 */
	public SkinOfCard getSkin() {
		return skin;
	}
	/**
	 * Liefert die Farbe der Karte
	 * @return
	 */
	public ColorOfCard getColor() {
		return color;
	}
	/**
	 * Diese Methode erzeugt ein 32 Kartenblatt und gibt es aus.
	 * @return
	 */
	public static Card[] generateNewCards() {
		SkinOfCard[] k = SkinOfCard.values();
		ColorOfCard[] c = ColorOfCard.values();
		Card[] out = new Card[32];
		for (int i = 0; i < out.length / 4; i++) {
			for (int j = 0; j < 4; j++) {
				out[i + (8 * j)] = new Card(k[SkinOfCard.SIEBEN.ordinal() + i],
						c[j]);
			}
		}
		return out;
	}
}
```

Hmm, danke für den Tip, ich schau mal, ob ich das irgendwie hinkrieg...


----------



## Lexi (10. Mai 2009)

Wenn es noch irgendwo haken sollte, nochmal nachfragen.
Jetzt fehlen nur noch die Klassen SkinOfCard und ColorOfCard


----------



## vensch (10. Mai 2009)

Wie mach ich denn das mit dem Player?


----------



## Lexi (10. Mai 2009)

vensch hat gesagt.:


> Wie mach ich denn das mit dem Player?



Was meinst du konkret damit ? 
Willst du wissen, wie du die createPlayer() Methode implementieren sollst ?


----------



## vensch (10. Mai 2009)

Ja


----------



## Lexi (10. Mai 2009)

Also entweder bin ich zu blöd oder die Aufgaben Stellung zu dieser Methode ist wirklich ein wenig komisch, ich blicke da nicht so ganz durch.

Ich habe es so verstanden, dass man ein neues Object vom Typ Player erzeugen und ihm den Namen z.B. "1" geben soll. Danach wird das neue Object returnt.

Ein neues Object instantierst du mit dem Schlüsselwort new, also mit einem Konstruktoraufruf:

```
Player myPlayer = new Player();
```
Das wäre der Aufruf, wenn die Klasse Player einen Parameterlosen Konstruktor hätte.

Hilft das schon weiter ?


----------



## vensch (13. Mai 2009)

Soo, nachdem ich mich letzte Woche noch ein paar Tage mit der Aufgabe gequält hab, hab ich es am Ende doch noch irgendwie geschafft, wenn auch nicht zu 100% richtig. 
Nun komm ich wieder nicht weiter (ist das normal oder bin ich einfach nur zu blöd dafür??!!).
Ich soll meine Klasse Game um die Methode getWish() erweitern, welche das Attribut wish
ausgibt (siehe Klassendiagramm) und die Methode getLastCardPlayed(), welche vom
CardStack field die letzte gesetzte Karte ausgibt (Hinweis: Die Methode, welche die
letzte gesetzte Karte ausgibt wurde in der Klasse CardStack schon geschrieben). Außerdem soll ich die Klasse Player um die Assoziation zur Klasse Game erweitern, d.h. um das Attribut und die get- und set-Methoden (siehe Klassendiagramm).

Könnt ihr mir bitte helfen? Ich blick da so langsam gar nicht mehr durch. 

Hier ist das Diagramm:







Und alle Klassen hab ich als zip-Datei hochgeladen (hier), weil es sonst etwas unübersichtlich geworden wäre, hätte ich die Klassen einzeln hier gepostet.
Wäre wirklich toll, wenn ihr mir helfen könntet, ich verzweifel hier schon...


----------



## Lexi (14. Mai 2009)

Also die getWish() Methode scheint ein ganz normaler getter zu sein.
Weißt du was ein getter ist ? - Wenn das der Fall ist sollte das kein Problem sein.
Außerdem ist diese Methode doch in Game schon definiert ?!

Zur getLastCardPlayed() Methode:
Wie die Aufgabe schon sagt, die Methode die du hierfür benötigst ist schon in CardStack definiert. Es ist eine Methode, die die oberste Karte des CardStacks zurückgibt.
Welche das ist müsstest du eigentlich wissen, sofern du schon ein bisschen mit Stacks vertraut bist. Solltest du dir noch nichts unter Stack vorstellen, kannst du dir am besten einmal kurz die API zu Gemüte führen und dort nach der Klasse Stack suchen.


----------



## vensch (16. Mai 2009)

Vom Prinzip her ist mir das schon klar, ich weiß nur irgendwie nicht, wie ich das in Code umsetzen soll... =/


----------



## vensch (16. Mai 2009)

Okay, bei getLastCardPlayed() hab ich jetzt folgendes:


```
public Card getLastCardPlayed() {
		int index = 0;
		while (index < cards.length && cards[index] != null) {
			index++;
		}
		if (index == 0)
			return null;
		index--;
		if (index < cards.length)
			return cards[index];
		return null;
	}
```

Das müsste eigentlich richtig sein, oder?
Bei der getWish() Methode weiß ich nicht, wie ich den Rückgabewert darstellen soll... ???:L


----------



## Lexi (16. Mai 2009)

Das mit den Rückgabe Werten ist eigentlich recht leicht zu verstehen, wenn man Vererbung jetzt erstmal außer Betracht lässt.

Du kannst jeden Typ mit dem du eine Variable oder einen Parameter deklarierst als Rückgabewert angeben:


```
//Eine Methode die ein IntegerWert zurückliefert:
public int rechne(int z1, int z2){
    return z1+z2;
}

//Hier ein Beispiel das ein Objekt des Typs "typDesRückgabeWertes" zurückgibt.
public typDesRückgabeWertes doSomething(){
    //....
    return variableMitTypDesRückgabeWertes;
}
```

Zu der Sache mit der getLastPlayed():
Dort greifst du auf die Variable cards zu. In welcher Klasse ist diese denn deklariert ?


----------

