einfaches Pokerprogramm

[SvenLindner]

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:

{ Hochste Einzelkarte
 Hohere (hochste) Karte gewinnt
 sonst Split Pot
{ Parchen
 Hoheres Parchen gewinnt
 sonst hohere (hochste) Einzelkarte gewinnt
 sonst Split Pot
{ 2 Parchen
 Hoheres hochstes Parchen gewinnt
 sonst hoheres niedrigeres Parchen gewinnt
 sonst hohere 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]

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]

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]

 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();

...

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

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]

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]

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]

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]

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]

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]

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]

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]

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]

Set (Java 2 Platform SE v1.4.2)

 

[SvenLindner]

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]

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]

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]

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]

	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]

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]

Ich rede gegen Windmühlen.

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

 

[SvenLindner]

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]

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]

	    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]

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]

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]

"Es werden nur folgende
Gewinnoptionen berucksichtigt:
{ Hochste Einzelkarte
 Hohere (hochste) Karte gewinnt
 sonst Split Pot
{ Parchen
 Hoheres Parchen gewinnt
 sonst hohere (hochste) Einzelkarte gewinnt
 sonst Split Pot
{ 2 Parchen
 Hoheres hochstes Parchen gewinnt
 sonst hoheres niedrigeres Parchen gewinnt
 sonst hohere 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]

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]

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]

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]

Klassen kannst du ja auch innerhalb einer anderen Klasse deklarieren.

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

 

[SvenLindner]

 

[SvenLindner]

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]

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]

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]

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]

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]

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]

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

 

[timbeau]

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

Und du kannst einiges davon nutzen.

 

[SvenLindner]

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]

Wo soll ich denn die Biere hinschicken?

 

[ARadauer]

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]

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]

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]

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]

Hilft mir jemand?!

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

 

[SvenLindner]

ich würd dir sogar dein Bier per Paypal schicken

 

[Painii]

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]

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]

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.