Hallo Leute,
hab folgendes Problem: es sollen vier Spieler (Threads) abwechselnd (gleiche reihenfolge) auf ein Kartendeck zugreifen und dabei ein Karte abheben und sobalt sie vier in der Hand also wenn sie die fünfte ziehen eine wieder ablegen. Das Ziel ist es vier von einem Typ zu haben(Quartet).
Mir ist leider nicht ganz klar wie ich die Threads nun am geschicktesten synchronisiere. Mein Ansatz ist sie in eine LinkedList zu geben und immer einen Thread zu nehmen in einer Runde spielen zu lassen und ihn dann wieder hinten rein zu hängen. Mir ist aber nicht klar ob das so überhaupt funktionieren kann. Vorallem ist mir nicht ganz klar was ich synchronized machen soll wenn ich so und so nur einem Thread zur gleichen Zeit erlaube zu spielen.
Hier mal was ich habe (ohne triviale Klassen).
Player:
Game:
Karten
Pile (Kartendeck)
also wenn ihr mir mal sagen könntet ob mein ansatz so richtig ist wär ich euch schon dankbar
wenn ihr noch informationen braucht schreibts bitte
hab folgendes Problem: es sollen vier Spieler (Threads) abwechselnd (gleiche reihenfolge) auf ein Kartendeck zugreifen und dabei ein Karte abheben und sobalt sie vier in der Hand also wenn sie die fünfte ziehen eine wieder ablegen. Das Ziel ist es vier von einem Typ zu haben(Quartet).
Mir ist leider nicht ganz klar wie ich die Threads nun am geschicktesten synchronisiere. Mein Ansatz ist sie in eine LinkedList zu geben und immer einen Thread zu nehmen in einer Runde spielen zu lassen und ihn dann wieder hinten rein zu hängen. Mir ist aber nicht klar ob das so überhaupt funktionieren kann. Vorallem ist mir nicht ganz klar was ich synchronized machen soll wenn ich so und so nur einem Thread zur gleichen Zeit erlaube zu spielen.
Hier mal was ich habe (ohne triviale Klassen).
Player:
Java:
import java.util.ArrayList;
import java.util.Collections;
public class Player extends Thread {
private ArrayList<Card> cards = new ArrayList<Card>();
private Pile pile;
private Card preferredCard1;
private Card preferredCard2;
public Player(String name, int p1, int p2, Pile p) {
super(name);
this.preferredCard1 = new Card(p1);
this.preferredCard2 = new Card(p2);
this.pile = p;
this.start();
}
public void play() {
run();
}
public void run() {
System.out.println(this.getName()+ " started!");
while(true) {
//ich wollte hier einfach wait() machen und darauf warten notify augerufen wird
draw(pile.getCard());
if(checkQuartet()) return;
pile.addCard(discard());
System.out.println(this.getName()+showHands());
}
}
private String showHands() {
return cards.toString();
}
public void draw(Card e) {
cards.add(e);
}
public Card discard() {
if (cards.size() < 5)
return null;
for (Card e : cards)
if (!e.equals(preferredCard1) && !e.equals(preferredCard2)) {
cards.remove(e);
return e;
}
Collections.sort(cards);
if (cards.get(0).equals(cards.get(2)))
return cards.remove(4);
return cards.remove(0);
}
public boolean checkQuartet() {
if (cards.size() < 4)
return false;
Collections.sort(cards);
if (cards.get(0).equals(cards.get(3)))
return true;
if (cards.size() > 4 && cards.get(1).equals(cards.get(4)))
return true;
return false;
}
}Game:
Java:
import java.util.LinkedList;
public class Game extends Thread {
private Pile pile;
private LinkedList<Player> players = new LinkedList<Player>();
public Game() {
pile = new Pile();
for(int i = 0; i<4; i++)
players.add(new Player("Player "+i,i,i+4, pile ));
}
// Hier hatte ich dann noch ne schleife im run die die Threads mittels Notify anstossen sollte
}Karten
Java:
public class Card implements Comparable<Card> {
private int type;
public Card(int type) {
this.type = type;
}
public int getType() {
return type;
}
public int compareTo(Card e) {
Integer a = new Integer(type);
Integer b = new Integer(e.getType());
return a.compareTo(b);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + type;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Card other = (Card) obj;
if (type != other.type)
return false;
return true;
}
@Override
public String toString() {
return "" + type;
}Pile (Kartendeck)
Java:
import java.util.Collections;
import java.util.LinkedList;
public class Pile {
private LinkedList<Card> pile = new LinkedList<Card>();
public Pile() {
for (int i = 0; i < 32; i++)
this.addCard(new Card(i % 8));
Collections.shuffle(pile);
}
public synchronized void addCard(Card e) {
if(e!=null)
pile.addLast(e);
}
public synchronized Card getCard() {
System.out.println(pile.size());
return pile.removeFirst();
}
public int size() {
return pile.size();
}
}also wenn ihr mir mal sagen könntet ob mein ansatz so richtig ist wär ich euch schon dankbar
wenn ihr noch informationen braucht schreibts bitte
