# einfaches Pokerprogramm



## SvenLindner (18. Jan 2011)

Hallo,
ich möchte gerne ein einfaches Pokerprogramm schreiben.


```
while(!end)
		{
			choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
			switch(choice)
			{
				case 1:
					while(!legalHand)
					{
						while(!legalCard)
						{
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der ersten Karte ein: 2-14"));
							c11.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der ersten Karte ein: 0-3"));
							c11.setColor(temp);
							if(legalCard(c11))
							{legalCard = true;} 
							
							else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
						}
						
						legalCard = false;
```

Das muss ich nun noch für die Karten 2-10 machen. 

Das Programm soll nicht alle Pokerregeln beachten, sondern nur:

{ Hochste Einzelkarte
 Hohere (hochste) Karte gewinnt
 sonst Split Pot
{ Parchen
 Hoheres Parchen gewinnt
 sonst hohere (hochste) Einzelkarte gewinnt
 sonst Split Pot
{ 2 Parchen
 Hoheres hochstes Parchen gewinnt
 sonst hoheres niedrigeres Parchen gewinnt
 sonst hohere Einzelkarte gewinnt
 sonst Split Pot

Außerdem soll das Programm testen ob es sich um "legalHands" handelt, also ob jede Kartenfarbenkombination nur einmal vorkommt. Das macht es ja schon, wenn man Karten selber von Hand eingibt, dabei sagt es ja immer, dass man illegal Hands eingegeben hat -> Was hab ich da falsch gemacht?

Und es soll, wie ihr seht, auch Hände generieren können, also solange zufällige Werte der Zahlen 2-14 (also 2 bis ass) und der Farben 0-3 generieren, für zwei Hände, dass wieder legal hands sind.
Die Methode mit der das bei 1, also bei selber eingegebenen Karten geprüft wird kann man sicher auch auf die generierten anwenden. Falls das Programm aber illegal Hands generiert hat muss es nochmal generieren, ohne irgendetwas auszugeben, solange bis es legal Hands generiert.

Ich bin über jede Hilfe dankbar.


----------



## timbeau (18. Jan 2011)

Wir sehen doch deine legalCard-Code überhaupt nicht. Das wäre das erste. Alle anderen Fragen kann man dann weiter besprechen wenn mal ein Grundgerüst vorhanden ist. Was ist denn bereits alles da?


----------



## SvenLindner (18. Jan 2011)

Vorhanden ist:


```
package x;

import javax.swing.*;
import java.util.Random;



public class Poker{

	public static Card c11; // Karte 1 Spieler 1
	public static Card c21; // Karte 2 Spieler 1
	public static Card c31; // ...
	public static Card c41;
	public static Card c51;
	public static Card c12; // Karte 1 Spieler 2
	public static Card c22; // ...
	public static Card c32;
	public static Card c42;
	public static Card c52;

	public static void main(String args[]){
		c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
		c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();

		int choice;
		boolean end = false;
		boolean legalCard = false;
		boolean legalHand = false;

		int temp;

		while(!end)
		{
			choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
			switch(choice)
			{
				case 1:
					while(!legalHand)
					{
						while(!legalCard)
						{
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der ersten Karte ein: 2-14"));
							c11.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der ersten Karte ein: 0-3"));
							c11.setColor(temp);
							if(legalCard(c11))
							{legalCard = true;} 
							
							else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
						}
						
						legalCard = false;
						
						
						
						// TODO
						// analog fuer Karten 2-10

						//TODO
						//Korrektheit der Haende bestimmen
					}

					//TODO
					// Gewinner bestimmen und ausgeben (mit calculateWinningHandReduced)

					//TODO
					// OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)

					break;
			    case 2:
					//TODO
					// Haende generieren und Gewinner ausgeben.
					// OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)


					break;
				default:
					end = true;
					break;
			}
		}

	}

	public static boolean legalCard(Card c)
	{
		return false;
		//TODO
	}

	public static boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return false;
		//TODO
	}

	public static int calculateWinningHandReduced(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO
	}

	public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst natuerlich korrekte Rueckgabewerte geben.
	}

	public void generateHands()
	{
		//TODO
	}

}
```

und 


```
package x;

public class Card {

int Value;
int Color;

public int setValue ()

{return Value;}

public void setValue (int Value)
{ this.Value = Value ;

}

public int setColor ()

{return Color;}

public void setColor (int Color)
{ this.Color = Color ; }

}
```

Nicht wundern, es gibt zwei Möglichkeiten das Programm zu lösen: Die einfache, die die ich machen möchte, dass nur die genannten Möglichkeiten für Sieg, Niederlage oder Splitpot funktionieren oder, dass alles was im realen Poker möglich ist funktioniert.


----------



## ARadauer (18. Jan 2011)

> ```
> public static Card c11; // Karte 1 Spieler 1
> public static Card c21; // Karte 2 Spieler 1
> public static Card c31; // ...
> ...


mhn ich würd mal einfach eine klasse Spieler machen, die die Karten des Spielers hält... wär sauberer...

btw was war die Frage?


----------



## ARadauer (18. Jan 2011)

ach ja ich würde mir eine saubere Code Formatierung angewöhnen... Klassen groß, Variablen und Methoden klein...


```
public class Card {
 
int Value;//klein!!
int Color;
 
public int setValue ()
 //warum ist hier eine leerzeile?
{return Value;}
 
public void setValue (int Value)  //ich wird die { hier her schreiben
{ this.Value = Value ;
 
}
 
public int setColor ()
 
{return Color;} //warum ist das alles in einer Zeile...
 
public void setColor (int Color)
{ this.Color = Color ; }
 
}
```
usw.. nur so als Tipp am Rande...


----------



## SvenLindner (18. Jan 2011)

Die Fragen waren wie ich 
1. Das Programm testen lassen kann, dass es eine LegalHand ist, also nur Farben und  Ziffern die erlaubt sind, sowie keine doppelt
2. Das Programm zwei zufällige Legal hands generieren lassen kann


----------



## timbeau (18. Jan 2011)

Du kannst auf Gleichheit prüfen indem du deine Karten Klasse equals überschreiben lässt und immer prüfst ob die Hand-Collection die Karte schon "contained"

Aber ich würde eher aus der Gesamtheit der Karten die gezogenen Karten löschen. Somit kann nur eine legal Hand auftreten.


----------



## SvenLindner (18. Jan 2011)

timbeau hat gesagt.:


> Aber ich würde eher aus der Gesamtheit der Karten die gezogenen Karten löschen. Somit kann nur eine legal Hand auftreten.



wie würde das aussehen?


----------



## timbeau (19. Jan 2011)

Was ist denn unklar?

Sagen wir du hast ein Set<deineKartenKlasse> alleKarten. Jetzt gehst du mittels Iterator durch dein Set und verteilst Karten. Wenn du nicht jede nehmen willst musst du dir noch bisschen Random einbauen. 

Dann entfernst du diese KArte mittels remove. Man kann auch eine Liste nehmen, die mittels Collections.shuffle durchschütteln und dann die Karten verteilen und dann löschen. 

Ist nur ein Vorschlag


----------



## ARadauer (19. Jan 2011)

> also nur Farben und Ziffern die erlaubt sind


mhn ok ich finde das zwar ein bisschen trivial aber vielleicht fehlt dir nur der ansatz..

also wie schon gesagt. du brauchst noch eine klasse Spieler bzw eine Klasse Hand die eine Liste mit Karten hält.

```
public static boolean legalHands(Hand hand){
   for(Card card : hand.getCards(){
       if(card.getValue() >14 || card.getValue() <2 || card.getColor() >3 || card.getColor() <0)
          return false;
       }
   }

   //hier noch auf doppelt überprüfen. am besten equals der Card überschreiben
   //dann in einer for schleif in ein Set einfügen, wenn schon drinnen dann wars doppelt
   return true;
}
```


----------



## SvenLindner (19. Jan 2011)

Ich erstelle jetzt eine liste mit allen möglichen Karten, die es geben kann (also mit 52 Karten) und dann ein Unterprogramm, dass legalCard heißt, dass prüft ob eine eingegebene Karte "Teil" dieser Liste ist. ja?


----------



## SvenLindner (19. Jan 2011)

Wie teste ich, ob eine Eingabe Teil eines von mir zuvor definierten Arrays ist?

Hab jetzt  
	
	
	
	





```
int [] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
int [] Color = {0,1,2,3};
```

Könnte dann ja mit if Bedingungen testen ob die Eingaben Teil dieses Arrays sind


----------



## timbeau (19. Jan 2011)

Set (Java 2 Platform SE v1.4.2)


----------



## SvenLindner (19. Jan 2011)

ich aktualisier die ganze Zeit, in der Hoffnung jemand hat geantwortet, aber da ich ja garkeine Frage gestellt habe, wird das nicht passieren.
timbeau ich hab dich bei Skype geaddet, wäre das einfachste, wenn du Lust und Zeit hast (obwohl das nicht ganz lange dauern wird) wenn du mal eben schnell on kommst und wir das mal eben machen.

Das ist die letzte Aufgabe für einen Schein und ich muss nur verstehen was gemacht wird, ich muss nicht unbedingt selber drauf kommen, was auch, denke ich, nichtmehr passieren wird.


----------



## SvenLindner (19. Jan 2011)

oder ist ein anderer Nutzer willens mir kurz bei Skype zu helfen? Das ganze wird nicht länger als 15 Minuten dauern und ihr müsst auch nicht mit mir reden, wenn ihr nicht wollt.


----------



## SvenLindner (19. Jan 2011)

Der übersichtlichkeit halber


```
package x;

import javax.swing.*;
import java.util.Random;



public class Poker{

	public static Card c11; // Karte 1 Spieler 1
	public static Card c21; // Karte 2 Spieler 1
	public static Card c31; // ...
	public static Card c41;
	public static Card c51;
	public static Card c12; // Karte 1 Spieler 2
	public static Card c22; // ...
	public static Card c32;
	public static Card c42;
	public static Card c52;

	
	
	
	
	
	public static void main(String args[]){
		c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
		c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();

		int choice;
		boolean end = false;
		boolean legalCard = false;
		boolean legalHand = false;

		int temp;


int [] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
int[] Color = {0,1,2,3};

		
		while(!end)
		{
			choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
			switch(choice)
			{
				case 1:
					while(!legalHand)
					{
						while(!legalCard)
						{
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der ersten Karte ein: 2-14"));
							c11.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der ersten Karte ein: 0-3"));
							c11.setColor(temp);
							if(legalCard(c11))
							{legalCard = true;} 
							
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie den Wert der zweiten Karte ein: 2-14"));
						c21.setValue(temp);
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie die Farbe der zweiten Karte ein: 0-3"));
						c21.setColor(temp);
						if(legalCard(c21))
						{legalCard = true;} 
						
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der dritten Karte ein: 2-14"));
							c31.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der dritten Karte ein: 0-3"));
							c31.setColor(temp);
							if(legalCard(c31))
							{legalCard = true;} 
							
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie den Wert der vierten Karte ein: 2-14"));
						c41.setValue(temp);
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie die Farbe der vierten Karte ein: 0-3"));
						c41.setColor(temp);
						if(legalCard(c41))
						{legalCard = true;} 	
						
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
						"Geben Sie den Wert der fünften Karte ein: 2-14"));
					c51.setValue(temp);
					temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
						"Geben Sie die Farbe der fünften Karte ein: 0-3"));
					c51.setColor(temp);
					if(legalCard(c51))
					{legalCard = true;} 	
						
					temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
					"Geben Sie den Wert der sechsten Karte ein (erste Karte Spieler 2) : 2-14"));
				c21.setValue(temp);
				temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
					"Geben Sie die Farbe der sechsten Karte ein: 0-3"));
				c21.setColor(temp);
				if(legalCard(c21))
				{legalCard = true;} 
					
				temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Geben Sie den Wert der siebten Karte ein: 2-14"));
				c22.setValue(temp);
			temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Geben Sie die Farbe der siebten Karte ein: 0-3"));
			c22.setColor(temp);
			if(legalCard(c22))
			{legalCard = true;} 
			
			
			temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie den Wert der achten Karte ein: 2-14"));
			c32.setValue(temp);
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie die Farbe der achten Karte ein: 0-3"));
		c32.setColor(temp);
		if(legalCard(c32))
		{legalCard = true;} 
		
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
		"Geben Sie den Wert der neunten Karte ein: 2-14"));
		c42.setValue(temp);
	temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
		"Geben Sie die Farbe der neunten Karte ein: 0-3"));
	c42.setColor(temp);
	if(legalCard(c42))
	{legalCard = true;}
	
	temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie den Wert der zehnten Karte ein: 2-14"));
			c52.setValue(temp);
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie die Farbe der zehnten Karte ein: 0-3"));
		c52.setColor(temp);
		if(legalCard(c52))
		{legalCard = true;}
	
				
							else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
						}
						
						legalCard = false;
						
						
						//TODO
						//Korrektheit der Haende bestimmen
					}

					//TODO
					// Gewinner bestimmen und ausgeben (mit calculateWinningHandReduced)

					//TODO
					// OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)

					break;
			    case 2:
					//TODO
					// Haende generieren und Gewinner ausgeben.
					// OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)


					break;
				default:
					end = true;
					break;
			}
		}

	}

	public static boolean legalCard(Card c)
	{
		return false;
		//TODO
	}

	public static boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return false;
		//TODO
	}

	public static int calculateWinningHandReduced(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO
	}

	public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst natuerlich korrekte Rueckgabewerte geben.
	}

	public void generateHands()
	{
		//TODO
	}

}
```

und


```
package x;

public class Card {

int Value;
int Color;

public int setValue ()

{return Value;}

public void setValue (int Value)
{ this.Value = Value ;

}

public int setColor ()

{return Color;}

public void setColor (int Color)
{ this.Color = Color ; }



}
```
Ich möchte gerne, dass der Test, ob es legalHands sind funktioniert und, dass das Programm in der Lage ist wenn "2" eingegeben wird, zwei zufällige Hände zu erstellen.


----------



## timbeau (19. Jan 2011)

Ich hab dir schon einen Vorschlag gemacht, nämlich alle Karten selbst zu generieren. Das ist total easy.

for i = 2 - 10  generiere alle 4 Farben.

Dann noch 4 buben, damen, könige und asse.

Damit hast du deinen Kartenstapel. und daraus ziehst du dann Karten.


----------



## SvenLindner (20. Jan 2011)

```
Random generator = new Random();
	
	
public class pickRand {
	    public Integer get (Integer[] array) {
	        int rnd = generator.nextInt(array.length);
	        return array[rnd];
	    }
	}	
	

		int[] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
		int ret = pickRand.get(Value);
```

Muss das in eine eigene Klasse? oder mache ich es nur an die falsche Stelle?


```
package grundlagenuebungen;

import javax.swing.*;
import java.util.Random;



public class Poker{

	public static Card c11; // Karte 1 Spieler 1
	public static Card c21; // Karte 2 Spieler 1
	public static Card c31; // ...
	public static Card c41;
	public static Card c51;
	public static Card c12; // Karte 1 Spieler 2
	public static Card c22; // ...
	public static Card c32;
	public static Card c42;
	public static Card c52;

	
	Random generator = new Random();
	
	
public class pickRand {
	    public Integer get (Integer[] array) {
	        int rnd = generator.nextInt(array.length);
	        return array[rnd];
	    }
	}	
	
	
	
	public static void main(String args[]){
		c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
		c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();

		int choice;
		boolean end = false;
		boolean legalCard = false;
		boolean legalHand = false;

		int temp;
		
		int[] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
		int ret = pickRand.get(Value);
```


----------



## SvenLindner (20. Jan 2011)

```
import java.util.Random;

public class pickRand {
	
	
	static Random generator = new Random();
	
	
    public static Integer get (int[] value) {
    int rnd = generator.nextInt(value.length);
    return value[rnd];
    }
}
```


----------



## timbeau (20. Jan 2011)

Ich rede gegen Windmühlen.

Da macht man keine Klasse sondern eine Methode die einem einfach ein int zurückgibt.


----------



## SvenLindner (20. Jan 2011)

timbeau hat gesagt.:


> Ich rede gegen Windmühlen.



Stimmt! Ich kann es ja auch nicht! Geht es denn mit ner eigenen Klasse einfach "garnicht" oder wird es 10x so kompliziert? Dann poste doch bitte die Methode, dann musst du dich weniger ärgern und ich komme schneller an Ziel. ;(


----------



## timbeau (20. Jan 2011)

Eine Methode die eine zufällig generierte Zahl innerhalb eines gegebenen Bereichs zurück gibt hast du quasi schon selber gebastelt. 


```
public int get (int lengthOfArray) {
    int rnd = generator.nextInt(lengthOfArray);
    return rnd;
    }
```


----------



## SvenLindner (20. Jan 2011)

```
case 2:
			    	
			    		
					int retV = pickRand.getV(Value);
					
					c11.setValue(retV);
				
			    	int retC = pickRand.getC(Color);
			    	
			    	c11.setColor(retC);
```

Du kannst mich gerne virtuell schlagen oder mit abgebrochenen Flaschenhälsen bewerfen, aber ich bin zu blöd um das aufzunehmen, was du gepostet hast.

Gehts quasi so, wenn ich  das jetzt für jede Karte mache?


----------



## SvenLindner (20. Jan 2011)

ok, also das klappt soweit, ich kann zufällige 10 Karten erstellen lassen.
Das Code ich mal eben.
Also nächstes möchte ich gucken wer gewinnt :-S Und ich hab immernoch nicht geschaut, ob die manuell eingegebenen Karten "legal" sind.


----------



## timbeau (20. Jan 2011)

Ich glaube wir müssen 2 Dinge trennen. 

Das eine ist die zufällige Verteilung der Karten auf die Hand, das andere die systematische Erstellung eines Karten Sets. 

Ein Pokerset besteht aus einer nicht(!) zufälligen Menge von Karten. Die sollte man also auch nicht zufällig generieren sondern z.B. so generieren: 


```
List<Spielkarten> kartenstapel = new ArrayList<Spielkarten>();
		for (int i = 0; i < 11; i++) {
			Spielkarten herzsk = new Spielkarten("herz", String.valueOf(i));
			Spielkarten piksk = new Spielkarten("pik", String.valueOf(i));
			/*
			 * ...
			 * ...
			 * 
			 */
			kartenstapel.add(herzsk);
			/*
			 * 3 anderen auch
			 */
		}
		
		
		/*
		 * Jetzt die Bilderkarten
		 */

Collections.shuffle(kartenstapel);
```


----------



## SvenLindner (20. Jan 2011)

"Es werden nur folgende
Gewinnoptionen berucksichtigt:
{ Hochste Einzelkarte
 Hohere (hochste) Karte gewinnt
 sonst Split Pot
{ Parchen
 Hoheres Parchen gewinnt
 sonst hohere (hochste) Einzelkarte gewinnt
 sonst Split Pot
{ 2 Parchen
 Hoheres hochstes Parchen gewinnt
 sonst hoheres niedrigeres Parchen gewinnt
 sonst hohere Einzelkarte gewinnt
 sonst Split Pot"

Es ist also egal ob ich Herz 10 und Karo 10 oder Herz 10 und Herz 10 hab.


Wenn das die Bedingung ist, ist dann die Farbe sowieso nicht egal?!?! Ich mein, dann ist für mein Programm Karo 10 doch das Gleiche wie Herz 10 und das Pärchen Herz 10 auch genausoviel wert wie Herz 10 Karo 10, oder?


----------



## SvenLindner (20. Jan 2011)

```
package x;

import javax.swing.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;



public class Poker{

	public static Card c11; // Karte 1 Spieler 1
	public static Card c21; // Karte 2 Spieler 1
	public static Card c31; // ...
	public static Card c41;
	public static Card c51;
	public static Card c12; // Karte 1 Spieler 2
	public static Card c22; // ...
	public static Card c32;
	public static Card c42;
	public static Card c52;

	


	
	
	
	public static void main(String args[]){
		c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
		c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();

		int choice;
		boolean end = false;
		boolean legalCard = false;
		boolean legalHand = false;

		int temp;
		
		int[] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
		
		int[] Color = {0,1,2,3};

	    List<Card> list1 = new ArrayList<Card>();
	     
		Card [] Cardsac  = {c11,c21,c31,c41,c51,c12,c22,c32,c42,c52};
		
		
		while(!end)
		{
			choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
			switch(choice)
			{
				case 1:
					while(!legalHand)
					{
						while(!legalCard)
						{
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der ersten Karte ein: 2-14"));
							c11.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der ersten Karte ein: 0-3"));
							c11.setColor(temp);
							if(legalCard(c11))
							{legalCard = true;} 
							
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie den Wert der zweiten Karte ein: 2-14"));
						c21.setValue(temp);
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie die Farbe der zweiten Karte ein: 0-3"));
						c21.setColor(temp);
						if(legalCard(c21))
						{legalCard = true;} 
						
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie den Wert der dritten Karte ein: 2-14"));
							c31.setValue(temp);
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
								"Geben Sie die Farbe der dritten Karte ein: 0-3"));
							c31.setColor(temp);
							if(legalCard(c31))
							{legalCard = true;} 
							
							temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie den Wert der vierten Karte ein: 2-14"));
						c41.setValue(temp);
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
							"Geben Sie die Farbe der vierten Karte ein: 0-3"));
						c41.setColor(temp);
						if(legalCard(c41))
						{legalCard = true;} 	
						
						temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
						"Geben Sie den Wert der fünften Karte ein: 2-14"));
					c51.setValue(temp);
					temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
						"Geben Sie die Farbe der fünften Karte ein: 0-3"));
					c51.setColor(temp);
					if(legalCard(c51))
					{legalCard = true;} 	
						
					temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
					"Geben Sie den Wert der sechsten Karte ein (erste Karte Spieler 2) : 2-14"));
				c21.setValue(temp);
				temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
					"Geben Sie die Farbe der sechsten Karte ein: 0-3"));
				c21.setColor(temp);
				if(legalCard(c21))
				{legalCard = true;} 
					
				temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Geben Sie den Wert der siebten Karte ein: 2-14"));
				c22.setValue(temp);
			temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
				"Geben Sie die Farbe der siebten Karte ein: 0-3"));
			c22.setColor(temp);
			if(legalCard(c22))
			{legalCard = true;} 
			
			
			temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie den Wert der achten Karte ein: 2-14"));
			c32.setValue(temp);
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie die Farbe der achten Karte ein: 0-3"));
		c32.setColor(temp);
		if(legalCard(c32))
		{legalCard = true;} 
		
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
		"Geben Sie den Wert der neunten Karte ein: 2-14"));
		c42.setValue(temp);
	temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
		"Geben Sie die Farbe der neunten Karte ein: 0-3"));
	c42.setColor(temp);
	if(legalCard(c42))
	{legalCard = true;}
	
	temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie den Wert der zehnten Karte ein: 2-14"));
			c52.setValue(temp);
		temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
			"Geben Sie die Farbe der zehnten Karte ein: 0-3"));
		c52.setColor(temp);
		if(legalCard(c52))
		{legalCard = true;}
	
		
			
			
							else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
						}
						
						legalCard = false;
						
						
						//TODO
						//Korrektheit der Haende bestimmen
					}

					//TODO
					// Gewinner bestimmen und ausgeben (mit calculateWinningHandReduced)

					//TODO
					// OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)

					break;
					
					
			    case 2:
			    	
			    		
					int retV1 = pickRand.getV(Value);
					
					c11.setValue(retV1);
				
			    	int retC1 = pickRand.getC(Color);
			    	
			    	c11.setColor(retC1);
			    	
			    	
			   
					
					int retV2 = pickRand.getV(Value);
					
					c21.setValue(retV2);
				
			    	int retC2 = pickRand.getC(Color);
			    	
			    	c21.setColor(retC2);
			    	
			   
			    	
					int retV3 = pickRand.getV(Value);
					
					c31.setValue(retV3);
				
			    	int retC3 = pickRand.getC(Color);
			    	
			    	c31.setColor(retC3);
			    	
			    	
					int retV4 = pickRand.getV(Value);
					
					c41.setValue(retV4);
				
			    	int retC4 = pickRand.getC(Color);
			    	
			    	c41.setColor(retC4);
			    	
			    	
			    	int retV5 = pickRand.getV(Value);
					
					c51.setValue(retV5);
				
			    	int retC5 = pickRand.getC(Color);
			    	
			    	c51.setColor(retC5);
			    	
			    	
			    	int retV6 = pickRand.getV(Value);
					
					c12.setValue(retV6);
				
			    	int retC6 = pickRand.getC(Color);
			    	
			    	c12.setColor(retC6);
			    	
			    	
			    	int retV7 = pickRand.getV(Value);
  	
					c22.setValue(retV7);
				
			    	int retC7 = pickRand.getC(Color);
			    	
			    	c22.setColor(retC7);
			    	
			    	
			    	int retV8 = pickRand.getV(Value);
					
					c32.setValue(retV8);
				
			    	int retC8 = pickRand.getC(Color);
			    	
			    	c32.setColor(retC8);
			    	
			    	
			    	int retV9 = pickRand.getV(Value);
					
					c42.setValue(retV9);
				
			    	int retC9 = pickRand.getC(Color);
			    	
			    	c42.setColor(retC9);
			    	
					
			    	int retV10 = pickRand.getV(Value);
					
					c52.setValue(retV10);
				
			    	int retC10 = pickRand.getC(Color);
			    	
			    	c52.setColor(retC10);
			    	
			    	
			    	break;
					
			    	default:
					end = true;
					break;
			}
		}

	}

	public static boolean legalCard(Card[] cardsac)

	
	{
	       if(Card.getValue() >14 || Card.getValue() <2 || Card.setColor() >3 || Card.setColor() <0)
	          return false;
	       }
	
	

	public static boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return false;
		//TODO
	}

	public static int calculateWinningHandReduced(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO
	}

	public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
	{
		return 3;
		//TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst natuerlich korrekte Rueckgabewerte geben.
	}

	public void generateHands()
	{
		//TODO
	}

}
```


```
package x;

public class Card {

int Value;
int Color;

public int setValue ()

{return Value;}

public void setValue (int Value)
{ this.Value = Value ;

}

public int setColor ()

{return Color;}

public void setColor (int Color)
{ this.Color = Color ; }

public int getValue ()
{return Value;}

public void getValue (int Value)

{this.Value = Value;}


}
```


```
package x;

import java.util.Random;

public class pickRand {
	
	
	static Random generator = new Random();
	
	
    public static Integer getV (int[] Value) {
    int rnd = generator.nextInt(Value.length);
    return Value[rnd];
    }
    
    public static Integer getC (int[] Color) {
        int rnd = generator.nextInt(Color.length);
        return Color[rnd];
        }
}
```

so weit. Ich hab alle Karten in die Arrayliste Cardsac getan. Es klappt die Methode "legalCards" noch nicht. Ansonsten klappt aber, dass nur "legal" Cards zufällig generiert werden. Schonmal erfreulich für mich 
Ich bin heute Abend wieder da! Danke schoneinmal für die viele Hilfe. Mit einem Schüler wie mir würde ich es nicht aushalten, glaub ich.


----------



## ARadauer (20. Jan 2011)

Du fragst etwas ... Leute geben dir Tipps
Du fragst wieder und hast diese Tipps ignoriert... -> die Leute geben dir keine Tipps mehr... bringt ja nix

 c11;c21;c31; c51;
was ist das? 51? Ist das deine Hausnummer?
Warum machst du dir nicht eine Klasse Spieler oder Hand die eine Liste mit Karten hat?
Mach das mal dann sehen wir weiter...

Das mit dem geben hab ich auch schon beschrieben. Erzeug dir deine Karten, 2 bis Ass für jede Farbe und füg sie in eine ArrayListe ein... dann mit shuffle mischen und mit remove(0) geben...

PS: Klassen groß, Variablen und Methoden klein schreiben!!


----------



## SvenLindner (20. Jan 2011)

ARadauer hat gesagt.:


> Warum machst du dir nicht eine Klasse Spieler oder Hand die eine Liste mit Karten hat?



Weil ich nur die Klassen Card und Poker benutzen darf, ich kann auch nur zwei Klassen als Lösung hochladen.

Ich setze die Tipps nicht nicht um weil ich so ein schlechter Mensch bin und euch ärgern will, oder weil es mir nichts wert ist, dass ihr versucht mir zu helfen, sondern weil ich zu dumm bin. Geht einfach von dem Standpunkt aus. Ich habs bis zu einem bestimmten Punkt kapiert, aber nicht weiter.

Also kann ich das Programm wie ich es jetzt gemacht hab auch nicht hochladen und abgeben. 
Das mit den Klassen und Variablen mit groß und klein änder ich jetzt.

Wie kann ich also die Aufgabe lösen ohne mehr als zwei Klassen zu erstellen? ich lad mal den Aufgabenzettel hoch.


----------



## timbeau (20. Jan 2011)

Klassen kannst du ja auch innerhalb einer anderen Klasse deklarieren. 

Ich verstehe nicht warum man jmd. zwingen sollte so Anti-Oo zu programmieren.


----------



## SvenLindner (20. Jan 2011)




----------



## SvenLindner (20. Jan 2011)

timbeau hat gesagt.:


> Klassen kannst du ja auch innerhalb einer anderen Klasse deklarieren.
> 
> Ich verstehe nicht warum man jmd. zwingen sollte so Anti-Oo zu programmieren.



Wenn ich das einfach reincopypaste 


```
package grundlagenuebungen;


import java.util.Random;

public class pickRand {
	
	
	static Random generator = new Random();
	
	
    public static Integer getV (int[] Value) {
    int rnd = generator.nextInt(Value.length);
    return Value[rnd];
    }
    
    public static Integer getC (int[] Color) {
        int rnd = generator.nextInt(Color.length);
        return Color[rnd];
        }
}	


public class Card {

int Value;
int Color;

public int setValue ()

{return Value;}

public void setValue (int Value)
{ this.Value = Value ;

}

public int setColor ()

{return Color;}

public void setColor (int Color)
{ this.Color = Color ; }

public int getValue ()
{return Value;}

public void getValue (int Value)

{this.Value = Value;}


}
```

Das klappt ja z.B. nicht!


----------



## timbeau (20. Jan 2011)

Richtig. 

Java ist auch eine Insel – 6.12 Innere Klassen

Für eine extra Klasse Hand würde ich aber keine innere Kalsse nehmen. 

JAVA: 6.1.1 Klassen deklarieren


----------



## SvenLindner (20. Jan 2011)

```
package grundlagenuebungen;

import java.util.Random;



public class Card {

int Value;
int Color;

public int setValue ()

{return Value;}

public void setValue (int Value)
{ this.Value = Value ;

}

public int setColor ()

{return Color;}

public void setColor (int Color)
{ this.Color = Color ; }

public int getValue ()
{return Value;}

public void getValue (int Value)

{this.Value = Value;}

static class pickRand {
	
	
	static Random generator = new Random();
	
	
    public static Integer getV (int[] Value) {
    int rnd = generator.nextInt(Value.length);
    return Value[rnd];
    }
    
    public static Integer getC (int[] Color) {
        int rnd = generator.nextInt(Color.length);
        return Color[rnd];
        }
}	


}
```
 SUCCESS


----------



## ARadauer (20. Jan 2011)

was SUCCESS??? Variablen sind noch immer groß
. der Setter in Zeile 21 ist ein Getter, der Getter in Zeile 31 ist Setter... ???


Soll die Karte jetzt eigentlich zufällig gegeben werden oder soll das manuell geschehen?

mmhnn ok ich helf dir mal..

alles was in switch(choice) { drinnen ist, kannst du weg werfen, das ist der komplette müll. Das siehst du ja selber dass da 10 mal der selbe Code steht... warum?



```
package x;

public class Card {
   
   private static String[] COLOR_NAMES = {"HERZ", "PIK", "KARO", "KREUZ"};
   private static String[] VALUE_NAMES = {"", "", "ZWEI", "DREI", "VIER", "FÜNF", "SECHS", "SIEBEN", "ACHT", "NEUEN", "ZEHN", "BUBE", "DAME", "KÖNIG", "ASS"};

   private int value; //Variablen klein!!!!
   private int color;
   
// public int setValue() { // ja klar!!
// return Value;
//}

   
   public Card(int value, int color) {
      this.value = value;
      this.color = color;
   }

   public int getValue() {
      return value;
   }
   
   public void setValue(int value) {
      this.value = value;
   }
   
   public int getColor() {
      return color;
   }
   
   public void setColor(int color) {
      this.color = color;
   }
   
   public String toString(){
      return COLOR_NAMES[color]+" "+VALUE_NAMES[value]+" ("+hashCode()+")";
   }

   @Override
   public int hashCode() {
     return color*13+value-1; //wow magie!!!
   }

   @Override
   public boolean equals(Object obj) {
      return hashCode() == obj.hashCode();
   }
   
   public boolean isIlegalCard(){
      return getValue() >14 || getValue() <2 || getColor() >3 || getColor() <0;
   }
  }
```


```
package x;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class Poker {

   public static void main(String[] args) {
      ArrayList<Card> deck = createDeck();
      System.out.println(deck.size() + " Karten im Deck"); // sollten 52 sein...

      // mischen...
      Collections.shuffle(deck);
      //geben
      Card[] handPlayer1 = new Card[5];
      Card[] handPlayer2 = new Card[5];
      for (int i = 0; i < 5; i++) {
         handPlayer1[i] = deck.remove(0);
         handPlayer2[i] = deck.remove(0);
      }
      
      System.out.println("Spieler 1:");
      for(Card c: handPlayer1){
         System.out.print(c+" | ");
      }

      System.out.println("\nSpieler 2:");
      for(Card c: handPlayer2){
         System.out.print(c+" | ");         
      }
      
      
      if(legalHands(handPlayer1, handPlayer2)){
         System.out.println("jup hand passt");
      }
   }

   public static ArrayList<Card> createDeck() {
      ArrayList<Card> deck = new ArrayList<Card>();
      for (int color = 0; color < 4; color++) {
         for (int value = 2; value < 15; value++) {
            Card card = new Card(value, color);
            deck.add(card);
            System.out.println(card + " eingefügt");
         }
      }
      return deck;
   }

   public static boolean legalHands(Card[] handPlayer1, Card[] handPlayer2) { // dann mach halt keine OBJEKTE aber schreib bitte nicht 10 mal Card

      Set<Card> setOfCards =new HashSet<Card>();
      for(Card card : handPlayer1){
         if(card.isIlegalCard()){ //kann gar nicht sein
            System.out.println("Karte "+card+" von Spieler 1 ist Müll!");
            return false;
         }
         setOfCards.add(card);
      }      
      for(Card card : handPlayer2){
         if(card.isIlegalCard()){ //kann gar nicht sein
            System.out.println("Karte "+card+" von Spieler 2 ist Müll!");
            return false;
         }
         setOfCards.add(card);
      }
      
     
      return setOfCards.size() == handPlayer1.length+ handPlayer2.length; // das ist magie.. das darfst du eh nicht machen.. 
      //du musst die zwei schleifen machen und jede mit jeder vergleichen...

   }

   public static int calculateWinningHandReduced(Card[] handPlayer1, Card[] handPlayer2) {
      if(isToPair(handPlayer1)){
         ... usw... 
         das mach ich jetzt nicht mehr...
      }
      return 3;
      // TODO
   }

   public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne,
         Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo) {
      // was kommt da rein?
      return 3;
      // TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst
      // natuerlich korrekte Rueckgabewerte geben.
   }

}
```


----------



## SvenLindner (20. Jan 2011)

EDIT: Erstmal Lesen was geantwortet wurde


Beitrag war: So, jetzt möchte ich einen Array erstellen mit allen Karten die möglich sind, also alle Karten die es beim Poker gibt. Macht mir das bitte jemand für die erste Karte vor, z.B. Karo 2 :rtfm:


----------



## ARadauer (20. Jan 2011)

SvenLindner hat gesagt.:


> EDIT: Erstmal Lesen was geantwortet wurde
> 
> 
> Beitrag war: So, jetzt möchte ich einen Array erstellen mit allen Karten die möglich sind, also alle Karten die es beim Poker gibt. Macht mir das bitte jemand für die erste Karte vor, z.B. Karo 2 :rtfm:



hö hö da war ich ja schon fertig bevor der wunsch kam ;-)

das ist das


```
public static ArrayList<Card> createDeck() {
      ArrayList<Card> deck = new ArrayList<Card>();
      for (int color = 0; color < 4; color++) {
         for (int value = 2; value < 15; value++) {
            Card card = new Card(value, color);
            deck.add(card);
            System.out.println(card + " eingefügt");
         }
      }
      return deck;
   }
```
im grunde ganz einfach...

wobei ich natürlich anmerken muss, das das eignetlich nicht sauber ist man müsste da statt den 4, 15 usw.. enums oder wenigstes final static int verwenden... aber für den anfang reicht es...


----------



## SvenLindner (20. Jan 2011)

Hast du dir eigentlich die Aufgabenstellung durchgelesen, also das Bild, die ich hochgeladen hab?


----------



## timbeau (20. Jan 2011)

Zumindest hat er dir mal etwas gecodet woran du seit 3 Tagen nicht weiter kommst. 

Und du kannst einiges davon nutzen.


----------



## SvenLindner (20. Jan 2011)

Ja dafür bin ich ihm auch sehr dankbar, hört sich grade böser an als es gemeint war, wenn ich das nochmal lese.

Ich mach jetzt weiter.


----------



## SvenLindner (21. Jan 2011)

Wo soll ich denn die Biere hinschicken?


----------



## ARadauer (21. Jan 2011)

> Hast du dir eigentlich die Aufgabenstellung durchgelesen, also das Bild, die ich hochgeladen hab?


ich seh das Bild nicht... liegt an unserer firewall in der firma
Aufgabenstellung... ja schon nur dein code dazu ist entwas difus... jetzt weiß ich nichit ob der user die karten wählt oder das zufallig passieren soll



> Soll die Karte jetzt eigentlich zufällig gegeben werden oder soll das manuell geschehen?


Ich denke ein Poker spiel wo jemand Karten aussucht ist sinnlos, also hab ichs so geschrieben...

Das mit den Bieren ist eher zum Spaß... aber wenn FullTilt Poker mal deine Software verwendet kannst du mir das Passwort für die Cheatfunktion geben ;-)


----------



## Painii (21. Jan 2011)

ARadauer hat gesagt.:


> Ich denke ein Poker spiel wo jemand Karten aussucht ist sinnlos, also hab ichs so geschrieben...



Ein Programm in das du eine Hand eingibts und es sagt dir welche Hand gewinnt?


----------



## ARadauer (21. Jan 2011)

ok stimmt...

Zur Vollständigkeit nochmal diese Links... das ist das was ich bei meinen Programmen zum Thema Poker benutze....
http://spaz.ca/poker/UofAHandEval.zip
Generated Documentation (Untitled)


----------



## SvenLindner (21. Jan 2011)

Wenn man bei dem Programm die Karten nicht selber bestimmen kann, dann kann man auch ein gaanz einfaches Zufallsprogramm schreiben, dass nur entscheidet ob Spieler 1 oder Spieler 2 gewinnt 


```
package x;
 
import javax.swing.*;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
 
 
public class Poker{
 
	class Card {
		 
		int Value;
		int Color;
		 
		public int setValue ()
		 
		{return Value;}
		 
		public void getValue (int Value)
		{ this.Value = Value ;
		 
		}
		 
		public int getColor ()
		 
		{return Color;}
		 
		public void setColor (int Color)
		{ this.Color = Color ; }
		 
		public int getValue ()
		{return Value;}
		 
		public void setValue (int Value)
		 
		{this.Value = Value;}
		 
		static class pickRand {
		    
		    
		    static Random generator = new Random();
		    
		    
		    public static Integer getV (int[] Value) {
		    int rnd = generator.nextInt(Value.length);
		    return Value[rnd];
		    }
		    
		    public static Integer getC (int[] Color) {
		        int rnd = generator.nextInt(Color.length);
		        return Color[rnd];
		        }
		}   
		 
		 
		}
	
    public static Card c11; // Karte 1 Spieler 1
    public static Card c21; // Karte 2 Spieler 1
    public static Card c31; // ...
    public static Card c41;
    public static Card c51;
    public static Card c12; // Karte 1 Spieler 2
    public static Card c22; // ...
    public static Card c32;
    public static Card c42;
    public static Card c52;
 
    
 
 
    
    
    
    public static void main(String args[]){
        c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
        c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();
 
        int choice;
        boolean end = false;
        boolean legalCard = false;
        boolean legalHand = false;
 
        int temp;
        
        int[] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
        
        int[] Color = {0,1,2,3};
 
        List<Card> list1 = new ArrayList<Card>();
         
        Card [] Cardsac  = {c11,c21,c31,c41,c51,c12,c22,c32,c42,c52};
        
        
        while(!end)
        {
            choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
            switch(choice)
            {
                case 1:
                    while(!legalHand)
                    {
                        while(!legalCard)
                        {
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie den Wert der ersten Karte ein: 2-14"));
                            c11.setValue(temp);
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie die Farbe der ersten Karte ein: 0-3"));
                            c11.setColor(temp);
                            if(legalCard(c11))
                            {legalCard = true;} 
                            
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie den Wert der zweiten Karte ein: 2-14"));
                        c21.setValue(temp);
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie die Farbe der zweiten Karte ein: 0-3"));
                        c21.setColor(temp);
                        if(legalCard(c21))
                        {legalCard = true;} 
                        
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie den Wert der dritten Karte ein: 2-14"));
                            c31.setValue(temp);
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie die Farbe der dritten Karte ein: 0-3"));
                            c31.setColor(temp);
                            if(legalCard(c31))
                            {legalCard = true;} 
                            
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie den Wert der vierten Karte ein: 2-14"));
                        c41.setValue(temp);
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie die Farbe der vierten Karte ein: 0-3"));
                        c41.setColor(temp);
                        if(legalCard(c41))
                        {legalCard = true;}     
                        
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                        "Geben Sie den Wert der fünften Karte ein: 2-14"));
                    c51.setValue(temp);
                    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                        "Geben Sie die Farbe der fünften Karte ein: 0-3"));
                    c51.setColor(temp);
                    if(legalCard(c51))
                    {legalCard = true;}     
                        
                    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                    "Geben Sie den Wert der sechsten Karte ein (erste Karte Spieler 2) : 2-14"));
                c21.setValue(temp);
                temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                    "Geben Sie die Farbe der sechsten Karte ein: 0-3"));
                c21.setColor(temp);
                if(legalCard(c21))
                {legalCard = true;} 
                    
                temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Geben Sie den Wert der siebten Karte ein: 2-14"));
                c22.setValue(temp);
            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Geben Sie die Farbe der siebten Karte ein: 0-3"));
            c22.setColor(temp);
            if(legalCard(c22))
            {legalCard = true;} 
            
            
            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie den Wert der achten Karte ein: 2-14"));
            c32.setValue(temp);
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie die Farbe der achten Karte ein: 0-3"));
        c32.setColor(temp);
        if(legalCard(c32))
        {legalCard = true;} 
        
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
        "Geben Sie den Wert der neunten Karte ein: 2-14"));
        c42.setValue(temp);
    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
        "Geben Sie die Farbe der neunten Karte ein: 0-3"));
    c42.setColor(temp);
    if(legalCard(c42))
    {legalCard = true;}
    
    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie den Wert der zehnten Karte ein: 2-14"));
            c52.setValue(temp);
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie die Farbe der zehnten Karte ein: 0-3"));
        c52.setColor(temp);
        if(legalCard(c52))
        {legalCard = true;}
    
        
            
            
                            else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
                        }
                        
                        legalCard = false;
                        
                        
                        //TODO
                        //Korrektheit der Haende bestimmen
                    }
 
                    //TODO
                    // Gewinner bestimmen und ausgeben (mit calculateWinningHandReduced)
 
                    //TODO
                    // OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)
 
                    break;
                    
                    
                case 2:
                    
                        
                    int retV1 = pickRand.getV(Value);
                    
                    c11.setValue(retV1);
                
                    int retC1 = pickRand.getC(Color);
                    
                    c11.setColor(retC1);
                    
                    
               
                    
                    int retV2 = pickRand.getV(Value);
                    
                    c21.setValue(retV2);
                
                    int retC2 = pickRand.getC(Color);
                    
                    c21.setColor(retC2);
                    
               
                    
                    int retV3 = pickRand.getV(Value);
                    
                    c31.setValue(retV3);
                
                    int retC3 = pickRand.getC(Color);
                    
                    c31.setColor(retC3);
                    
                    
                    int retV4 = pickRand.getV(Value);
                    
                    c41.setValue(retV4);
                
                    int retC4 = pickRand.getC(Color);
                    
                    c41.setColor(retC4);
                    
                    
                    int retV5 = pickRand.getV(Value);
                    
                    c51.setValue(retV5);
                
                    int retC5 = pickRand.getC(Color);
                    
                    c51.setColor(retC5);
                    
                    
                    int retV6 = pickRand.getV(Value);
                    
                    c12.setValue(retV6);
                
                    int retC6 = pickRand.getC(Color);
                    
                    c12.setColor(retC6);
                    
                    
                    int retV7 = pickRand.getV(Value);
    
                    c22.setValue(retV7);
                
                    int retC7 = pickRand.getC(Color);
                    
                    c22.setColor(retC7);
                    
                    
                    int retV8 = pickRand.getV(Value);
                    
                    c32.setValue(retV8);
                
                    int retC8 = pickRand.getC(Color);
                    
                    c32.setColor(retC8);
                    
                    
                    int retV9 = pickRand.getV(Value);
                    
                    c42.setValue(retV9);
                
                    int retC9 = pickRand.getC(Color);
                    
                    c42.setColor(retC9);
                    
                    
                    int retV10 = pickRand.getV(Value);
                    
                    c52.setValue(retV10);
                
                    int retC10 = pickRand.getC(Color);
                    
                    c52.setColor(retC10);
                    
                    
                    break;
                    
                    default:
                    end = true;
                    break;
            }
        }
 
    }
 
    public static boolean legalCard(Card[] cardsac)
 
    
    {
           if(Card.getValue() >14 || Card.getValue() <2 || Card.setColor() >3 || Card.setColor() <0)
              return false;
           }
    
    
 
    public static boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return false;
        //TODO
    }
 
    public static int calculateWinningHandReduced(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return 3;
        //TODO
    }
 
    public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return 3;
        //TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst natuerlich korrekte Rueckgabewerte geben.
    }
 
    public void generateHands()
    {
        //TODO
    }
 
}
```

Ich darf sogar nur EINE Klasse abgeben! Wie bescheuert ist das denn?!
Jetzt hab ich versucht die Card Klasse mit dem Randomkram hier in meinen Pokerklasse einzufügen, das hat nicht geklappt, obwohl ich eigentlich weiß, wie es theoretisch gehen sollten. Hilft mir jemand?!


----------



## ARadauer (21. Jan 2011)

> Hilft mir jemand?!


Ich nicht mehr... kann jemand anderes machen...


----------



## SvenLindner (21. Jan 2011)

ich würd dir sogar dein Bier per Paypal schicken


----------



## Painii (21. Jan 2011)

Du hast eine Methode legalHands(Karten...).
Diese gibt dir true zurück, wenn die Wahl der Karten erlaubt ist, false falls nicht.
Lass dir Karten eingeben (per Hand/zufällig), dann gib die Karten in die Methode legalHands.
Wenn true zurückkomt, berechne wer gewinnt, sonst wiederhole das eingeben.

Bau das erstmal formal auf, nur mit Methodenaufrufen (die Methoden baust du danach zusammen).
Damit lässt sich dein Ablauf vielleicht besser verfolgen.

Wenn du einen Fehler bekommst wo wir helfen sollen, schreib den Fehler bitte dazu.

Und letztlich, in deiner Card-Klasse ist immer noch der GETTER setValue() vorhanden... Der kann prinzipiell weg, weil drunter ja noch ein getValue() ist.


----------



## ARadauer (21. Jan 2011)

SvenLindner hat gesagt.:


> ich würd dir sogar dein Bier per Paypal schicken



bringt nix.. warum? Darum:

```
public void getValue (int Value)
        { this.Value = Value ;
         
        }
```
was denkst du dir bei sowas?
1. Variablen klein schreiben!!!! Hab ich schon 3 mal gesagt!
2. Formatierung ist scheiße!
3. das ist gar kein Getter, das ist ein Setter!!! wurde auch schon 2-3 mal hier gepostet

Euer Lehrer macht sich die Mühe euch wirklich eine einfache coole Aufgaben zu geben und du machst sowas... ???:L???:L

Schade... :bahnhof:


----------



## SvenLindner (21. Jan 2011)

Fehler: "The method legalCard(Poker.Card[]) in the type Poker is not applicable for the arguments (Poker.Card)"

und mein Code sieht jetzt so aus. Ich versuch jetzt die method legalCard zu coden.


```
package x;
 
import javax.swing.*;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
 
 
public class Poker{
 
	class Card {
		 
		int value;
		int color;
		
		
		
		
		public void getValue (int value)
	
		{ this.value = value ;}
		 
		public int getColor ()
		 
		{return color;}
		 
		public void setColor (int Color)
		{ this.color = Color ;}
		 
		public int getValue ()
		{return value;}
		 
		public void setValue (int value)
		 
		{this.value = value;}}
		 
		static class pickRand {
		    
		    
		    static Random generator = new Random();
		    
		    
		    public static Integer getV (int[] Value) {
		    int rnd = generator.nextInt(Value.length);
		    return Value[rnd];}
		    
		    
		    public static Integer getC (int[] Color) {
		        int rnd = generator.nextInt(Color.length);
		        return Color[rnd];}
		}   
		 
		 
		
	
    public static Card c11; // Karte 1 Spieler 1
    public static Card c21; // Karte 2 Spieler 1
    public static Card c31; // ...
    public static Card c41;
    public static Card c51;
    public static Card c12; // Karte 1 Spieler 2
    public static Card c22; // ...
    public static Card c32;
    public static Card c42;
    public static Card c52;
 
    
 
 
    
    
    
    public static void main(String args[]){
        c11 = new Card(); c21 = new Card(); c31 = new Card(); c41 = new Card(); c51 = new Card();
        c12 = new Card(); c22 = new Card(); c32 = new Card(); c42 = new Card(); c52 = new Card();
 
        int choice;
        boolean end = false;
        boolean legalCard = false;
        boolean legalHand = false;
 
        int temp;
        
        int[] Value = {2,3,4,5,6,7,8,9,10,11,12,13,14};
        
        int[] Color = {0,1,2,3};
 
        Card [] Cardsac  = {c11,c21,c31,c41,c51,c12,c22,c32,c42,c52};
        
        
        while(!end)
        {
            choice = Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Wollen sie 10 Karten eingeben geben Sie 1 ein,\n Wollen sie Karten zufaellig generieren geben Sie 2 ein\n wollen Sie das Programm beenden geben sie irgendwas anderes ein"));
            switch(choice)
            {
                case 1:
                    while(!legalHand)
                    {
                        while(!legalCard)
                        {
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie den Wert der ersten Karte ein: 2-14"));
                            c11.setValue(temp);
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie die Farbe der ersten Karte ein: 0-3"));
                            c11.setColor(temp);
                            if(legalCard(c11))
                            {legalCard = true;} 
                            
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie den Wert der zweiten Karte ein: 2-14"));
                        c21.setValue(temp);
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie die Farbe der zweiten Karte ein: 0-3"));
                        c21.setColor(temp);
                        if(legalCard(c21))
                        {legalCard = true;} 
                        
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie den Wert der dritten Karte ein: 2-14"));
                            c31.setValue(temp);
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                                "Geben Sie die Farbe der dritten Karte ein: 0-3"));
                            c31.setColor(temp);
                            if(legalCard(c31))
                            {legalCard = true;} 
                            
                            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie den Wert der vierten Karte ein: 2-14"));
                        c41.setValue(temp);
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                            "Geben Sie die Farbe der vierten Karte ein: 0-3"));
                        c41.setColor(temp);
                        if(legalCard(c41))
                        {legalCard = true;}     
                        
                        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                        "Geben Sie den Wert der fünften Karte ein: 2-14"));
                    c51.setValue(temp);
                    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                        "Geben Sie die Farbe der fünften Karte ein: 0-3"));
                    c51.setColor(temp);
                    if(legalCard(c51))
                    {legalCard = true;}     
                        
                    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                    "Geben Sie den Wert der sechsten Karte ein (erste Karte Spieler 2) : 2-14"));
                c21.setValue(temp);
                temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                    "Geben Sie die Farbe der sechsten Karte ein: 0-3"));
                c21.setColor(temp);
                if(legalCard(c21))
                {legalCard = true;} 
                    
                temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Geben Sie den Wert der siebten Karte ein: 2-14"));
                c22.setValue(temp);
            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
                "Geben Sie die Farbe der siebten Karte ein: 0-3"));
            c22.setColor(temp);
            if(legalCard(c22))
            {legalCard = true;} 
            
            
            temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie den Wert der achten Karte ein: 2-14"));
            c32.setValue(temp);
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie die Farbe der achten Karte ein: 0-3"));
        c32.setColor(temp);
        if(legalCard(c32))
        {legalCard = true;} 
        
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
        "Geben Sie den Wert der neunten Karte ein: 2-14"));
        c42.setValue(temp);
    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
        "Geben Sie die Farbe der neunten Karte ein: 0-3"));
    c42.setColor(temp);
    if(legalCard(c42))
    {legalCard = true;}
    
    temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie den Wert der zehnten Karte ein: 2-14"));
            c52.setValue(temp);
        temp =Integer.parseInt(JOptionPane.showInputDialog(null, 
            "Geben Sie die Farbe der zehnten Karte ein: 0-3"));
        c52.setColor(temp);
        if(legalCard(c52))
        {legalCard = true;}
    
        
            
            
                            else {JOptionPane.showMessageDialog(null, "Illegale Eingabe");}
                        }
                        
                        legalCard = false;
                        
                        
                        //TODO
                        //Korrektheit der Haende bestimmen
                    }
 
                    //TODO
                    // Gewinner bestimmen und ausgeben (mit calculateWinningHandReduced)
 
                    //TODO
                    // OPTIONAL: Echte Gewinner bestimmen und ausgeben (calculateWinningHand)
 
                    break;
                    
                    
                case 2:
                    
                        
                    int retV1 = pickRand.getV(Value);
                    
                    c11.setValue(retV1);
                
                    int retC1 = pickRand.getC(Color);
                    
                    c11.setColor(retC1);
                    
                    
               
                    
                    int retV2 = pickRand.getV(Value);
                    
                    c21.setValue(retV2);
                
                    int retC2 = pickRand.getC(Color);
                    
                    c21.setColor(retC2);
                    
               
                    
                    int retV3 = pickRand.getV(Value);
                    
                    c31.setValue(retV3);
                
                    int retC3 = pickRand.getC(Color);
                    
                    c31.setColor(retC3);
                    
                    
                    int retV4 = pickRand.getV(Value);
                    
                    c41.setValue(retV4);
                
                    int retC4 = pickRand.getC(Color);
                    
                    c41.setColor(retC4);
                    
                    
                    int retV5 = pickRand.getV(Value);
                    
                    c51.setValue(retV5);
                
                    int retC5 = pickRand.getC(Color);
                    
                    c51.setColor(retC5);
                    
                    
                    int retV6 = pickRand.getV(Value);
                    
                    c12.setValue(retV6);
                
                    int retC6 = pickRand.getC(Color);
                    
                    c12.setColor(retC6);
                    
                    
                    int retV7 = pickRand.getV(Value);
    
                    c22.setValue(retV7);
                
                    int retC7 = pickRand.getC(Color);
                    
                    c22.setColor(retC7);
                    
                    
                    int retV8 = pickRand.getV(Value);
                    
                    c32.setValue(retV8);
                
                    int retC8 = pickRand.getC(Color);
                    
                    c32.setColor(retC8);
                    
                    
                    int retV9 = pickRand.getV(Value);
                    
                    c42.setValue(retV9);
                
                    int retC9 = pickRand.getC(Color);
                    
                    c42.setColor(retC9);
                    
                    
                    int retV10 = pickRand.getV(Value);
                    
                    c52.setValue(retV10);
                
                    int retC10 = pickRand.getC(Color);
                    
                    c52.setColor(retC10);
                    
                    
                    break;
                    
                    default:
                    end = true;
                    break;
            }
        }
 
    }
 
    public static boolean legalCard(Card[] cardsac)
 
    
    {
           if(Card.getValue() >14 || Card.getValue() <2 || Card.setColor() >3 || Card.setColor() <0)
              return false;
           }
    
    
 
    public static boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return false;
        //TODO
    }
 
    public static int calculateWinningHandReduced(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return 3;
        //TODO
    }
 
    public static int calculateWinningHand(Card cardOnePlayerOne, Card cardTwoPlayerOne, Card cardThreePlayerOne, Card cardFourPlayerOne, Card cardFivePlayerOne, Card cardOnePlayerTwo, Card cardTwoPlayerTwo, Card cardThreePlayerTwo, Card cardFourPlayerTwo, Card cardFivePlayerTwo)
    {
        return 3;
        //TODO Optionale Methode. Wenn nicht programmiert so lassen, sonst natuerlich korrekte Rueckgabewerte geben.
    }
 
    public void generateHands()
    {
        //TODO
    }
 
}
```

Radauer, ich studier Wirtschaftsingenieurwesen. Ich weiß nicht, wozu ich Programmierung können soll, was mir das eines Tages nützen wird. Ich will es auch garnicht können und auch mein Prof meinte, dass wir das nur lernen, damit wir die Arbeit die Programmierer in Unternehmen leisten zu schätzen wissen. Die Lektion hab ich gelernt.


----------



## SvenLindner (21. Jan 2011)

```
public static boolean legalHands(Card carsac)
    {
    	if ( cardsac )
    	
    		c11 != c21 != c31 != c41 != c51 != c12 != c22 != c32 != c42 != c52;
    	
    	
    		return true;
    	
    	
    	else ;
    	 
        return false;
     
    }
```
Vielleicht versteht ihr an meinem "falschen" Code was ich machen möchte.
Wenn CardonePlayerOne bis CardFivePlayerTwo unterschiedlich voneiander sind, dann sind es legalCards, also true. Kann mir da jemand helfen?


----------



## Painii (22. Jan 2011)

SvenLindner hat gesagt.:


> ```
> public static boolean legalHands(Card carsac)
> {
> if ( cardsac )
> ...



Du hast da stehen:
c11 != c21 UND c21!=c31 UND ...
Das verhindert nicht, dass c11==c31 ist.
Was cardsac, carsac machen soll weiss ich nicht.
In dem Methodenkopf sollen 10 Card-Objekte angenommen werden, nicht das was du da hast.
Ausserdem.

Bau eine Methode readCard(), die von der Konsole eine Karte eingeben lässt.
Das macht deine andere Methode übersichtlicher - da steht nur noch der Abschnitt unten, readCard macht ja IMMER das gleiche. (Für den Fall das manuell eingegeben wird).
Falls du zufällig deine Karten bauen willst, dann machs dir auch so einfach wie möglich, mache eine Methode wie readCard(), nur dass sie halt keine Karte einliest sondern eine zufällige generiert.
Ja, dann können auch zwei gleiche gemacht werden.

```
c11 = readCard();
c21 = readCard();
//... Genauso für den Fall dass es zufällig sein soll.
```

Danach schaust du einmal, ob die zusammengestellte Hand (die einzelnen Variablen c11...c52) passt mit:

```
legalHand = legalCards(c11,c21,c31,c41,c51,c12,c22,c32,c42,c52)
```
Die while-schleife läuft dann solange !legalHand erfüllt ist

Laut Aufgabenstellung sollst du es mit den einzelnen Variablen machen, also lass das Array von ARadauer lieber erstmal raus... (produziert zwar unschöneren Code, aber besser es funkioniert erstmal, oder?)


----------



## tommysenf (22. Jan 2011)

Da dich die gesamte Thematik eigentlich gar nicht interessiert poste ich dir hier einfach mal eine mögliche Lösung anstatt dich weiter zu Quälen. Versuche aber zumindest einmal nachzuvollziehen was das Programm macht, oder frage nach wenn dir etwas unklar ist.


```
import java.util.HashSet;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;

public class Poker {

	private static final int HAND_SIZE = 5;
	private static final int IDX_HIGH_PAIR = 0;
	private static final int IDX_LOW_PAIR = 1;
	private static final int IDX_HIGHCARD = 2;
	private static final int PLAYERONE = 1;
	private static final int PLAYERTWO = 2;
	private static final int SPLIT = 0;

	private static Card[] playerOne = new Card[HAND_SIZE];
	private static Card[] playerTwo = new Card[HAND_SIZE];

	public boolean legalHands(Card cardOnePlayerOne, Card cardTwoPlayerOne,
			Card cardThreePlayerOne, Card cardFourPlayerOne,
			Card cardFivePlayerOne, Card cardOnePlayerTwo,
			Card cardTwoPlayerTwo, Card cardThreePlayerTwo,
			Card cardFourPlayerTwo, Card cardFivePlayerTwo) {

		Set<Card> testSet = new HashSet<Card>();
		testSet.add(cardOnePlayerOne);
		testSet.add(cardTwoPlayerOne);
		testSet.add(cardThreePlayerOne);
		testSet.add(cardFourPlayerOne);
		testSet.add(cardFivePlayerOne);
		testSet.add(cardOnePlayerTwo);
		testSet.add(cardTwoPlayerTwo);
		testSet.add(cardThreePlayerTwo);
		testSet.add(cardFourPlayerTwo);
		testSet.add(cardFivePlayerTwo);
		return testSet.size() == 10;

	}

	public void generateHands() {

		Random random = new Random();
		do {
			for (int i = 0; i < HAND_SIZE; i++) {
				playerOne[i] = new Card(random.nextInt(13) + 2,
						random.nextInt(4));
				playerTwo[i] = new Card(random.nextInt(13) + 2,
						random.nextInt(4));
			}
		} while (!legalHands(playerOne[0], playerOne[1], playerOne[2],
				playerOne[3], playerOne[4], playerTwo[0], playerTwo[1],
				playerTwo[2], playerTwo[3], playerTwo[4]));
	}

	public boolean legalCard(Card card) {
		return card.getColor() >= 0 && card.getColor() <= 3
				&& card.getValue() >= 2 && card.getValue() <= 14;
	}

	public int calculateWinningHandReduced(Card cardOnePlayerOne,
			Card cardTwoPlayerOne, Card cardThreePlayerOne,
			Card cardFourPlayerOne, Card cardFivePlayerOne,
			Card cardOnePlayerTwo, Card cardTwoPlayerTwo,
			Card cardThreePlayerTwo, Card cardFourPlayerTwo,
			Card cardFivePlayerTwo) {

		int[] resPlayerOne = getResult(cardOnePlayerOne, cardTwoPlayerOne,
				cardThreePlayerOne, cardFourPlayerOne, cardFivePlayerOne);

		int[] resPlayerTwo = getResult(cardOnePlayerTwo, cardTwoPlayerTwo,
				cardThreePlayerTwo, cardFourPlayerTwo, cardFivePlayerTwo);

		int critHighPair = compare(resPlayerOne[IDX_HIGH_PAIR],
				resPlayerTwo[IDX_HIGH_PAIR]);
		if (critHighPair == SPLIT) {
			int critLowPair = compare(resPlayerOne[IDX_LOW_PAIR],
					resPlayerTwo[IDX_LOW_PAIR]);
			if (critLowPair == SPLIT) {
				return compare(resPlayerOne[IDX_HIGHCARD],
						resPlayerTwo[IDX_HIGHCARD]);
			} else {
				return critLowPair;
			}
		} else {
			return critHighPair;
		}
	}

	private int compare(int playerOne, int playerTwo) {

		if (playerOne == playerTwo) {
			return SPLIT;
		}
		return playerOne > playerTwo ? PLAYERONE : PLAYERTWO;

	}

	private int[] getResult(Card... cards) {

		int maxPair = 0, minPair = 0, highCard = 0;

		for (int testValue = 14; testValue > 1; testValue--) {
			boolean found = false;
			for (Card card : cards) {
				if (card.getValue() == testValue)
					if (highCard == 0) {
						highCard = testValue;
						if (found) {
							if (maxPair == 0) {
								maxPair = testValue;
							} else if (minPair == 0) {
								minPair = testValue;
							}
							if (highCard == testValue) {
								highCard = 0;
							}
						} else {
							found = true;
						}
					}
			}

		}

		return new int[] { maxPair, minPair, highCard };
	}

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		Poker poker = new Poker();

		System.out.println("Wollen Sie die Karten");
		System.out.println("\t1) Manuell eingeben");
		System.out.println("\t2) Automatisch generieren");

		System.out.print(">");
		int option = scanner.nextInt();

		if (option == 1) {
			cardInput(scanner, poker, "Spieler 1", playerOne);
			cardInput(scanner, poker, "Spieler 2", playerTwo);
			if (!poker.legalHands(playerOne[0], playerOne[1], playerOne[2],
					playerOne[3], playerOne[4], playerTwo[0], playerTwo[1],
					playerTwo[2], playerTwo[3], playerTwo[4])) {

				System.out
						.println("Ungültge Eingabe. Das Programm wird beendet.");
				System.exit(3);

			}
		} else if (option == 2) {
			poker.generateHands();
		} else {
			System.out.println("Ungültge Eingabe. Das Programm wird beendet.");
			System.exit(1);
		}

		System.out.println("\nDie Karten von Spieler 1:");
		for (Card card : playerOne) {
			System.out.println("\t" + card);
		}
		System.out.println("\nDie Karten von Spieler 2:");
		for (Card card : playerTwo) {
			System.out.println("\t" + card);
		}

		int winner = poker.calculateWinningHandReduced(playerOne[0],
				playerOne[1], playerOne[2], playerOne[3], playerOne[4],
				playerTwo[0], playerTwo[1], playerTwo[2], playerTwo[3],
				playerTwo[4]);

		if (winner == SPLIT) {
			System.out.println("Splitpot!!!");
		} else {
			System.out.println("\nSpieler " + winner + " hat gewonnen!!!");
		}
	}

	private static void cardInput(Scanner scanner, Poker poker, String player,
			Card[] deck) {
		for (int i = 0; i < 5; i++) {
			System.out.println("\nEingabe der " + (i + 1) + ". Karte von "
					+ player);

			System.out.print("\tBitte geben Sie eine " + "Farbe (0 - 3) ein >");
			int color = scanner.nextInt();

			System.out.print("\tBitte geben Sie einen einen "
					+ "Wert (2 - 14) ein >");
			int value = scanner.nextInt();

			playerOne[i] = new Card(value, color);
			if (poker.legalCard(deck[i])) {
				System.out.println("\t" + deck[i] + " hinzugefügt");
			} else {
				System.out
						.println("Ungültge Eingabe. Das Programm wird beendet.");
				System.exit(2);
			}
		}
	}

}

class Card {

	private int value, color;

	public Card(int value, int color) {
		super();
		this.value = value;
		this.color = color;
	}

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public int getColor() {
		return color;
	}

	public void setColor(int color) {
		this.color = color;
	}

	@Override
	public String toString() {

		String text = "error";

		switch (color) {
		case 0:
			text = "Kreuz ";
			break;
		case 1:
			text = "Pik ";
			break;
		case 2:
			text = "Herz ";
			break;
		case 3:
			text = "Karo ";
			break;
		}

		if (value < 11) {
			text += value;
		} else {
			switch (value) {
			case 11:
				text += "Bube";
				break;
			case 12:
				text += "Dame";
				break;
			case 13:
				text += "König";
				break;
			case 14:
				text += "Ass";
				break;
			}
		}
		return text;
	}

	@Override
	public boolean equals(Object other) {

		if (this == other) {
			return true;
		}
		if (!(other instanceof Card)) {
			return false;
		}
		Card otherCard = (Card) other;
		return getColor() == otherCard.getColor()
				&& getValue() == otherCard.getValue();
	}
}
```


----------

