Problem mit Set, Stack und Random

[doenis]

Moin!

Ich studiere Informatik im ersten Semester und wir haben die Aufgaben bekommen, Blackjack mit abgewandelten Regeln zu programmieren. Das soll mit einem Skatblatt gespielt werden, daher darf ja jede Karte nur 4 mal vorkommen(farbe egal).

Mein Ansatz dazu ist ein set mit 32 zahlen zu fuellen, diese in einen Stack zu packen und zum kartenziehen einfach den obersten wert poppen.

Das Problem ist jetzt, das ich bei jedem Start vom Programm die gleichen Karten in der gleichen Reihenfolge ziehe, obwohl Random immer andere Werte in das Set schmeisst.

Ich hoffe ihr koennt mir da helfen

[Java]
import java.util.HashSet;
import java.util.Stack;


public class Testat2_17u4 {

/**
*
* @
*
*/

static Stack<Double> stapel = new Stack<Double>();


public static void main(String[] args) {
int punkteSpieler;
char spielen = 'j';

// Aufruf der Methoden zum Spielen, Punkteauswertung und Moeglichkeit, dass Spiel neuzustarten

do{
karten_mischen();
System.out.println("Das Spiel beginnt!");
punkteSpieler = spieler_spielt();

if (punkteSpieler < 21){
System.out.println("Sie haben "+punkteSpieler+" Punkte, nun ist der Computer am Zug");
computer_spielt(punkteSpieler);
System.out.println("Nochmal? j/n");
spielen = In.readChar();
}

else if (punkteSpieler == 21){
System.out.println("21 Punkte! Sie haben gewonnen");
System.out.println("Nochmal? j/n");
spielen = In.readChar();
}
else if (punkteSpieler > 21){
System.out.println("Sie haben mehr als 21 Punkte! Sie haben leider verloren.");
System.out.println("Nochmal? j/n");
spielen = In.readChar();
}
}
while (spielen == 'j'); //Wird die Frage Nochmal? mit j beantwortet, so startet ein neuer Durchlauf des Spiels.



}
/**
* In dieser Methode werden die Karten und damit die Punkte des Spielers ermittelt
* @return Gesamtpunkte des Spielers, wenn er sich uebernommen hat oder keine Karte mehr ziehen moechte
*/
public static int spieler_spielt(){
int punkte = 0;
char ziehen = 'j';
double karte = 0;


// Solange nach jeder karte die Frage nach einer weiteren bejaht wird
// und die punkte des Spielers nicht 21 ueberschreiten, wird weitergespielt
while (ziehen == 'j' && punkte <= 21){

// Aufruf der Methode karte_ziehen(), welche einen Zufaelligen Integerwert zurueckgibt
karte = stapel.pop();


// Addieren des kartenwertes zum aktuellen punktestand und Ausgabe dessen
if (karte == 0 || karte == 1 || karte == 2 || karte == 3) {
punkte += 7;
System.out.println("Sieben, Gesamtpunkte:" +punkte);
}
else if (karte == 4 || karte == 5 || karte == 6 || karte == 7) {
punkte += 8;
System.out.println("Acht, Gesamtpunkte:" +punkte);
}
else if (karte == 8 || karte == 9 || karte == 10 || karte == 11) {
punkte += 9;
System.out.println("Neun, Gesamtpunkte:" +punkte);
}
else if (karte == 12 || karte == 13 || karte == 14 || karte == 15) {
punkte += 10;
System.out.println("Zehn, Gesamtpunkte:" +punkte);
}
else if (karte == 16 || karte == 17 || karte == 18 || karte == 19) {
punkte += 1;
System.out.println("Bube, Gesamtpunkte:" +punkte);
}
else if (karte == 20 || karte == 21 || karte == 22 || karte == 23) {
punkte += 1;
System.out.println("Dame, Gesamtpunkte:" +punkte);
}
else if (karte == 24 || karte == 25 || karte == 26 || karte == 27) {
punkte += 1;
System.out.println("Koenig, Gesamtpunkte:" +punkte);
}
else if (karte == 28 || karte == 29 || karte == 30 || karte == 31) {
punkte += 11;
System.out.println("Ass, Gesamtpunkte:" +punkte);
}

// Die Schleife wird sofort verlassen, wenn die punkte groeßer oder gleich 21 sind,
// sodass der Spieler nicht noch eine karte ziehen kann
if ( punkte >=21){
break;
}

System.out.println("Noch eine karte ziehen? j/n");
ziehen = In.readChar();
}

return punkte;



}


/** In dieser Methode Spielt der Computer. Er zieht solange neue karten,
* bis er Entweder mehr Punkte als der Spieler hat oder er ueber 21 Punkte hat.
* @param Punkte_Mensch
*/

public static void computer_spielt(int punkteMensch){
int punkteComputer = 0;
double kartenwert = 0;

while (punkteComputer <= punkteMensch){

kartenwert= stapel.pop();


if (kartenwert == 0 || kartenwert == 1 || kartenwert == 2 || kartenwert == 3) {
punkteComputer += 7;
System.out.println("Sieben, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 4 || kartenwert == 5 || kartenwert == 6 || kartenwert == 7) {
punkteComputer += 8;
System.out.println("Acht, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 8 || kartenwert == 9 || kartenwert == 10 || kartenwert == 11) {
punkteComputer += 9;
System.out.println("Neun, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 12 || kartenwert == 13 || kartenwert == 14 || kartenwert == 15) {
punkteComputer += 10;
System.out.println("Zehn, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 16 || kartenwert == 17 || kartenwert == 18 || kartenwert == 19) {
punkteComputer += 1;
System.out.println("Bube, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 20 || kartenwert == 21 || kartenwert == 22 || kartenwert == 23) {
punkteComputer += 1;
System.out.println("Dame, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 24 || kartenwert == 25 || kartenwert == 26 || kartenwert == 27) {
punkteComputer += 1;
System.out.println("Koenig, Gesamtpunkte:" +punkteComputer);
}
else if (kartenwert == 28 || kartenwert == 29 || kartenwert == 30 || kartenwert == 31) {
punkteComputer += 11;
System.out.println("Ass, Gesamtpunkte:" +punkteComputer);
}


}

if (punkteComputer > punkteMensch && punkteComputer <= 21){
System.out.println("Der Computer hat "+punkteComputer+" Punkte und damit gewonnen");
}


else if ( punkteComputer > 21){
System.out.println("Der Computer hat sich uebernommen, Sie haben gewonnen!");
}




}


/**
* Diese Methode schreibt 32 Zufallszahlen in ein Hashset. Da in einem Set jeder Wert nur einmal vorhanden sein kann,
* ist gewaerleistet, dass in dem Stack stapel, der den kartenstapel repraesentiert, jede karte nur einmal vorkommt.
*/
public static void karten_mischen(){
double i = 0 ;
HashSet deck = new HashSet();

deck.clear();
stapel.clear();

while (deck.size()<= 31){
i = (int) (Math.random()* 63)/2;
System.out.println(+i);
deck.add(i);
}


java.util.Iterator it = deck.iterator();

while (it.hasNext()){
stapel.push((Double) it.next());
}
}




}
[/Java]

 

[eRaaaa]

also ich denke es liegt am iterator. der iteriert da immer gleich drüber.

ich würde evtl. einfach alle zahlen in deinen stack stecken, und dann einfach Collections.shuffle(stapel) nutzen, um den stapel zu sortieren. dann ist zwar der sinn vom stack verloren gegangen, aber so würde es funktionieren. (vllt auch garnicht einen stack benutzen sondern eine einfache liste)

	public static void karten_mischen() {
		for (int i = 1; i <= 32; i++) {
			stapel.push((double)i);
		}
		Collections.shuffle(stapel);
	}

wobei ich den stapel einmal füllen würde(am anfang irgendwo), und in der karten_mischen() dann einfach nur noch [c]Collections.shuffle(stapel);[/c] aufrufen würde.

 

[doenis]

vllt auch garnicht einen stack benutzen sondern eine einfache liste.

dann muesste ich mich noch darum kuemmern, dass kein index 2 mal aufgerufen wird, was bei meinem wissensstand noch eine globale variable bedeuten wuerde und "globale variablen sind der teufel" sinngemaess unserer professorin.

aber deine loesung funktioniert echt klasse, kp warum ich mir das so schwer gemacht hab^^

vielen dank