Skip to content
Snippets Groups Projects
Commit 78a2ed43 authored by Justin Klein's avatar Justin Klein
Browse files

Merge branch 'Frontend-patch-73a8' into 'master'

Der große Merge

See merge request !1
parents 06f34f96 d57163f3
No related branches found
No related tags found
1 merge request!1Der große Merge
UnoKarten/Wild_Multicolor_Gelb.png

7.78 KiB

UnoKarten/Wild_Multicolor_Gruen.png

7.69 KiB

UnoKarten/Wild_Multicolor_Rot.png

7.86 KiB

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class EndScreen extends Thread {
public void EndScreen(SpielerHand spielerHand, int spielerIndex){
JFrame frame = new JFrame();
frame.setTitle("End Screen");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
JPanel ende1 = new JPanel(new BorderLayout());
frame.add(ende1, BorderLayout.CENTER);
JPanel ende2 = new JPanel(new BorderLayout());
frame.add(ende2, BorderLayout.NORTH);
JPanel ende3 = new JPanel(new BorderLayout());
ende2.add(ende3, BorderLayout.CENTER);
ende1.setLayout(new BoxLayout(ende1, BoxLayout.X_AXIS));
JTextArea Sieger = new JTextArea();
int zahl = spielerIndex;
Sieger.setText("Der Gewinner ist: \n Player" + (zahl + 1) + " " + spielerHand.spielerNamen[spielerIndex]);
ende3.add(Sieger);
Sieger.setFont(new Font("Arial", Font.PLAIN, 40));
JButton NeueRundeButton = new JButton("Neue Runde");
ende1.add(NeueRundeButton);
NeueRundeButton.setFont(new Font("Arial", Font.PLAIN, 30));
NeueRundeButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
protected Void doInBackground() throws Exception {
UNO.main(new String[0]);
return null;
}
};
worker.execute();
frame.dispose();
}
});
JButton Beenden = new JButton("Beenden");
ende1.add(Beenden);
Beenden.setFont(new Font("Arial", Font.PLAIN, 30));
Beenden.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
frame.pack();
frame.setVisible(true);
}
//Es wird ein EndScreen erstellt der den Siger anzeigt.
//Es gibt den Knopf "Neue Runde", was eine neue Runde beginnen lässt
//Es gibt den Knopf "Beenden", was das Spiel Beendet
}
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.text.PlainDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
public class PlayerNamesInput extends JFrame {
private JTextField[] nameFields;
private JCheckBox[] botCheckboxes;
protected ArrayList<String> Names;
protected ArrayList<Boolean> isBot;
Object locked1 = null;
public PlayerNamesInput(Object locked) {
locked1 = locked;
setTitle("Spielernamen eingeben");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new FlowLayout());
JLabel playerCountLabel = new JLabel("Anzahl der Spieler:");
add(playerCountLabel);
SpinnerNumberModel spinnerModel = new SpinnerNumberModel(2, 2, 8, 1); // Spieleranzahl zwischen 2 und 8
JSpinner playerCountSpinner = new JSpinner(spinnerModel);
add(playerCountSpinner);
JButton playButton = new JButton("Play");
playButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int playerCount = (int) playerCountSpinner.getValue();
showPlayerNamesInput(playerCount);
}
});
add(playButton);
setSize(200,100);
setLocationRelativeTo(null);
setVisible(true);
//Es wird ein fenster mit der größe 200 x 200 erstellt, indem man zwischen 2 und 8 Spielern auswählen kann
}
private void showPlayerNamesInput(int playerCount) {
getContentPane().removeAll();
setLayout(new GridLayout(playerCount + 1, 3));
JLabel[] labels = new JLabel[playerCount];
nameFields = new JTextField[playerCount];
botCheckboxes = new JCheckBox[playerCount];
for (int i = 0; i < playerCount; i++) {
labels[i] = new JLabel("Spieler " + (i + 1) + ": ");
nameFields[i] = new JTextField(10);
int maxLength = 10; // Maximale Länge des Textfelds
nameFields[i].setDocument(new PlainDocument() {
@Override
public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
if (str == null)
return;
if ((getLength() + str.length()) <= maxLength) {
super.insertString(offset, str, attr);
}
}
});
botCheckboxes[i] = new JCheckBox("Bot");
JPanel panel = new JPanel(new FlowLayout());
panel.add(labels[i]);
panel.add(nameFields[i]);
panel.add(botCheckboxes[i]);
add(panel);
}
JButton submitButton = new JButton("Submit");
submitButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Names = new ArrayList<String>();
isBot = new ArrayList<Boolean>();
for (int i = 0; i < playerCount; i++) {
Names.add(nameFields[i].getText());
isBot.add(botCheckboxes[i].isSelected());
}
//showPlayerNames(playerNames, isBot);
synchronized (locked1) {
locked1.notify();
}
dispose();
}
});
add(submitButton);
setSize(800,800);
revalidate();
repaint();
//Es wird ein fenster erstellt, mit der größe 800 x 800.
//In diesem Fenster befindet sich für jeden Spiler ein eingabe Feld für den jeweiligen Namen
//Zusätzlich gibt es ein Hacken. Damit lässt sich auswählen ob der "Spieler" eine Bot sein wird
}
private void showPlayerNames(String[] playerNames, boolean[] isBot) {
getContentPane().removeAll();
setLayout(new FlowLayout());
JLabel playerLabel = new JLabel("Spieler:");
add(playerLabel);
for (int i = 0; i < playerNames.length; i++) {
JLabel nameLabel = new JLabel(playerNames[i] + (isBot[i] ? " (Bot)" : ""));
add(nameLabel);
}
setSize(800, 700);
setLocationRelativeTo(null);
setVisible(true);
}
public String getNames(int i){
return Names.get(i);
}
public int getgroesse(){
return Names.size();
}
public ArrayList<Boolean> getisBot(){
return isBot;
}
}
...@@ -8,34 +8,33 @@ public class Regelwerk { ...@@ -8,34 +8,33 @@ public class Regelwerk {
public ArrayList<Integer> reihenfolge; public ArrayList<Integer> reihenfolge;
public ArrayList<Farbe> color; public ArrayList<Farbe> color;
public void reihenfolgeFestlegen() { // spieler index in Array gespeichert public void reihenfolgeFestlegen(int length) {
reihenfolge = new ArrayList<Integer>(); reihenfolge = new ArrayList<Integer>();
reihenfolge.add(0, 0); // index , value for(int i = 0; i < length; i++) {
reihenfolge.add(1, 1); reihenfolge.add(i,i);
reihenfolge.add(2, 2); }
reihenfolge.add(3, 3);
} }
public UnoKarte ersteKarte(UnoDeck hand, int zug, int anzahl) { public UnoKarte ersteKarte(UnoDeck hand, int zug, int anzahl) {
if (zug == 1) { if (zug == 1) {
Random rand = new Random(); // random zahl wird generriert Random rand = new Random();
int n = rand.nextInt(anzahl); // random zahl von 0 bis DeckSize wird in n gespeichert int n = rand.nextInt(anzahl);
UnoKarte aktuellekarte = hand.get(n); // n wird in aktuelle karte gespeichert UnoKarte aktuellekarte = hand.get(n);
System.out.println("Die Aktuelle Karte:"); System.out.println("Die Aktuelle Karte:");
System.out.println(aktuellekarte); // ausgabe System.out.println(aktuellekarte);
return aktuellekarte; return aktuellekarte;
} }
return hand.get(1); return hand.get(1);
} }
public void aktuelleKarte(UnoKarte letzteKarte) { public void aktuelleKarte(UnoKarte letzteKarte) {
System.out.println("Die Aktuelle Karte:"); System.out.println("Die Aktuelle Karte:");
System.out.println(letzteKarte); // ausgabe aktuelle karte System.out.println(letzteKarte);
} }
public int reihenfolge() { public int reihenfolge() {
int aktuell = reihenfolge.get(0); // erster spieler wird gespeichert int aktuell = reihenfolge.get(0);
reihenfolge.remove(0); //erster spieler wird geklöscht reihenfolge.remove(0);
reihenfolge.add(aktuell); // erster spieler wird am ende des arrays eingefügt reihenfolge.add(aktuell);
return aktuell; return aktuell;
} }
public void wunschFestlegen(){ public void wunschFestlegen(){
...@@ -43,91 +42,90 @@ public class Regelwerk { ...@@ -43,91 +42,90 @@ public class Regelwerk {
color.add(0,Farbe.Wild); color.add(0,Farbe.Wild);
} }
public boolean karteLegbar(UnoKarte aktuellekarte, UnoKarte neueKarte, String PlayerName[], UnoDeck deck, SpielerHand spielerHand) { public boolean karteLegbar(UnoKarte aktuellekarte, UnoKarte neueKarte, UnoDeck deck, SpielerHand spielerHand, int lenght) {
if (color.size() == 2) {// wird erst bei einem kartenWunsch genutzt if (color.size() == 2) {
System.out.println("Wunchfarbe: " + color.get(1)); if ((color.get(1) == neueKarte.getFarbe()) || (color.get(0) == neueKarte.getFarbe())) {
if ((color.get(1) == neueKarte.getFarbe()) || (color.get(0) == neueKarte.getFarbe())) { // bedingung wunschfarbe selbe wie aktuelle Karten farbe oder bedingung ist wild auf wild color.remove(1);
color.remove(1); // karte wird gelegt return Lege(aktuellekarte, neueKarte,deck, spielerHand,lenght);
return Lege(aktuellekarte, neueKarte, PlayerName, deck, spielerHand);
}else { }else {
return false; return false;
} }
} else { // wird aufgerufen wenn keine wunschfarbe existiert } else {
return Lege(aktuellekarte, neueKarte, PlayerName, deck, spielerHand); return Lege(aktuellekarte, neueKarte, deck, spielerHand,lenght);
} }
} }
public boolean Lege(UnoKarte aktuellekarte, UnoKarte neueKarte,String PlayerName[], UnoDeck deck, SpielerHand spielerHand){ public boolean Lege(UnoKarte aktuellekarte, UnoKarte neueKarte,UnoDeck deck, SpielerHand spielerHand, int lenght){
if ((aktuellekarte.getFarbe() == neueKarte.getFarbe()) || (Farbe.Wild == neueKarte.getFarbe()) || ((aktuellekarte.getFarbe() == Farbe.Wild) && (Farbe.Wild != neueKarte.getFarbe()))) {// Farb kontrolle -> Bedingungen ob legbar oder nicht if ((aktuellekarte.getFarbe() == neueKarte.getFarbe()) || (Farbe.Wild == neueKarte.getFarbe()) || ((aktuellekarte.getFarbe() == Farbe.Wild) && (Farbe.Wild != neueKarte.getFarbe()))) {
if (neueKarte.getWert() == Wert.Zwei_Ziehen) { if (neueKarte.getWert() == Wert.Zwei_Ziehen) {
Ziehen(PlayerName, deck, 2, spielerHand); Ziehen(deck, 2, spielerHand);
} else if (neueKarte.getWert() == Wert.Aussetzen) { } else if (neueKarte.getWert() == Wert.Aussetzen) {
aussetzen(); aussetzen();
} else if (neueKarte.getWert() == Wert.Richtungswechsel) { } else if (neueKarte.getWert() == Wert.Richtungswechsel) {
richtungaendern(); richtungaendern(lenght);
} else if (neueKarte.getWert() == Wert.Multicolor) { } else if (neueKarte.getWert() == Wert.Multicolor) {
wunschFarbe(); //wunschFarbe();
}else if (neueKarte.getWert() == Wert.Draw_Four) { }else if (neueKarte.getWert() == Wert.Draw_Four) {
wunschFarbe(); //wunschFarbe();
Ziehen(PlayerName, deck, 4, spielerHand); Ziehen(deck, 4, spielerHand);
} }
return true; return true;
} else if ((aktuellekarte.getWert() == neueKarte.getWert()) || (Farbe.Wild == neueKarte.getFarbe()) || ((aktuellekarte.getFarbe() == Farbe.Wild) && (Farbe.Wild != neueKarte.getFarbe()))) {// Wert kontrolle -> (zB gruene vier geht auft blaue vier) } else if ((aktuellekarte.getWert() == neueKarte.getWert()) || (Farbe.Wild == neueKarte.getFarbe()) || ((aktuellekarte.getFarbe() == Farbe.Wild) && (Farbe.Wild != neueKarte.getFarbe()))) {
if (neueKarte.getWert() == Wert.Zwei_Ziehen) { if (neueKarte.getWert() == Wert.Zwei_Ziehen) {
Ziehen(PlayerName, deck, 2, spielerHand); Ziehen(deck, 2, spielerHand);
} else if (neueKarte.getWert() == Wert.Aussetzen) { } else if (neueKarte.getWert() == Wert.Aussetzen) {
aussetzen(); aussetzen();
} else if (neueKarte.getWert() == Wert.Richtungswechsel) { } else if (neueKarte.getWert() == Wert.Richtungswechsel) {
richtungaendern(); richtungaendern(lenght);
}else if (neueKarte.getWert() == Wert.Multicolor) { }else if (neueKarte.getWert() == Wert.Multicolor) {
wunschFarbe(); //wunschFarbe();
}else if (neueKarte.getWert() == Wert.Draw_Four) { }else if (neueKarte.getWert() == Wert.Draw_Four) {
wunschFarbe(); //wunschFarbe();
Ziehen(PlayerName, deck, 4, spielerHand); Ziehen(deck, 4, spielerHand);
} }
return true; return true;
} }
return false; return false;
} }
public void Ziehen(String PlayerName[], UnoDeck deck, int anzahl,SpielerHand spielerHand){ public void Ziehen(UnoDeck deck, int anzahl,SpielerHand spielerHand){
int spieler = reihenfolge.get(0); int spieler = reihenfolge.get(0);
spielerHand.befuelleSpieleHand(spieler, deck, anzahl); spielerHand.befuelleSpieleHand(spieler, deck, anzahl);
} }
public void aussetzen(){ public void aussetzen(){
int aktuell = reihenfolge.get(0);// spieler wird in aktuell gespeichert int aktuell = reihenfolge.get(0);
reihenfolge.remove(0);// nächster spieler wird gelöscht reihenfolge.remove(0);
reihenfolge.add(aktuell);// wird am ende des arrays hinzugefügt reihenfolge.add(aktuell);
} }
public void richtungaendern(){ public void richtungaendern(int lenght){
int [] richtungswechsel = new int[4];// neuer array richtungswechsel int [] richtungswechsel = new int[lenght];
for(int i = 0; i < reihenfolge.size(); i++){ for(int i = 0; i < reihenfolge.size(); i++){
richtungswechsel[i] = reihenfolge.get(i);// kopiervorgang der spieler zu richtungswechsel richtungswechsel[i] = reihenfolge.get(i);
} }
int size = reihenfolge.size(); int size = reihenfolge.size();
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
reihenfolge.remove(0);// löscht die einträge vom altem array reihenfolge.remove(0);
} }
for(int i = 3; i >= 0; i--){ for(int i = size-1; i >= 0; i--){
reihenfolge.add(richtungswechsel[i]);// werte werden umgekehrt in den alten array wieder eingefügt reihenfolge.add(richtungswechsel[i]);
} }
int zwischen = reihenfolge.get(0); // erster spieler wird in zwischen gespeichert int zwischen = reihenfolge.get(0);
reihenfolge.remove(0);// erster spieler wird gelöscht reihenfolge.remove(0);
reihenfolge.add(zwischen);// erster spieler wird im array neu eingefügtr aber hinten reihenfolge.add(zwischen);
} }
public void wunschFarbe(){ public void wunschFarbe(){
System.out.println("Welche Farbe möchteswt du?(Gruen, Blau, Gelb, Rot)"); System.out.println("Welche Farbe möchteswt du?(Gruen, Blau, Gelb, Rot)");
switch (scanner.nextLine().toLowerCase()){ switch (scanner.nextLine().toLowerCase()){
case "gruen": case "gruen":
color.add(Farbe.Gruen);// fügt in den array eine gruene Karte hinzu so kann als nächstes nur gruen gelegt werden color.add(Farbe.Gruen);
break; break;
case "blau": case "blau":
color.add(Farbe.Blau);// " color.add(Farbe.Blau);
break; break;
case "gelb": case "gelb":
color.add(Farbe.Gelb);// " color.add(Farbe.Gelb);
break; break;
case "rot": case "rot":
color.add(Farbe.Rot);// " color.add(Farbe.Rot);
break; break;
} }
} }
......
public class RunGame {
UnoDeck deck = new UnoDeck();
Regelwerk regel = new Regelwerk();
farbAuswahl farbAuswahl = new farbAuswahl();
EndScreen Ende = new EndScreen();
final Object lock = new Object();
final Object locked = new Object();
private int lenght = 0;
public void Start() {
PlayerNamesInput Names = new PlayerNamesInput(locked);
synchronized (locked) {
try {
locked.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//Es wird so Lange gewartet bis die Eingabe der Spieler Namen abgeschlossen ist
lenght = Names.getgroesse();
if (lenght > 4) {
deck.befuellen();
deck.befuellen();
} else {
deck.befuellen();
}
//Bei mehr als 4 Spilern sind 108 Karten zu wenig, deswegen werden die Karten verdoppelt (116 Karten)!
deck.mischeHand();
regel.wunschFestlegen();
String[] PlayerNames = new String[lenght];
int i;
for (i = 0; i < lenght; i++) {
PlayerNames[i] = Names.getNames(i);
}
SpielerHand spielerhand = new SpielerHand(lenght, PlayerNames);
for (i = 0; i < lenght; i++) {
spielerhand.befuelleSpieleHand(i, deck, 7);
spielerhand.zeigeHaende(i);
}
regel.reihenfolgeFestlegen(lenght);
//Die Spieler Namen werden verarbeitet und jeder Spieler bekommt die Hand gefüllt
GameLoop(spielerhand);
}
public void GameLoop(SpielerHand spielerHand) {
boolean win = false;
int zug = 1;
int legeKarte;
int spieler;
int reihen = 0;
UnoKarte aktuelleKarte = regel.ersteKarte(deck, zug, deck.hand.size());
boolean geht = false; //Das boolean hilft bei der kontrolle ob die Karte legbar ist!!!!
UnoSpielfeld spielFeld = new UnoSpielfeld(aktuelleKarte, spielerHand, regel,lock,lenght);
while (!win) {
reihen = regel.reihenfolge();
spielFeld.colorPlayer(reihen);
boolean start = false;
spielFeld.highZugStarten();
while (start != true) {
start = spielFeld.getzugStarten();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//Die Schleife Wartet bis der Zug vom Spiler gestartet wird
}
spielFeld.highZugStartenundo();
spielFeld.KarteHinzufuegen(spielerHand,reihen);
spielFeld.aktuelleKarte(aktuelleKarte);
boolean kartelegen = false;
boolean karteziehen = false;
while ((kartelegen || karteziehen) != true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
kartelegen = spielFeld.getkartelegen();
karteziehen = spielFeld.getkarteziehen();
//Diese Schleife wartet bis der Spieler sich zwischen Karte Legen und Karte Ziehen entschieden hat
}
if (kartelegen == true) {
UnoKarte neueKarte = spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielFeld.getKartenIndex());
geht = true;
//Entscheidet der Spieler sich für das legen der Karte wird wird die zu legende Karte entnommen
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte, deck, spielerHand,lenght)) {
spielerHand.entferneKarteHand(spielFeld.getSpielerIndex(), spielFeld.getKartenIndex()+1, deck, zug);
aktuelleKarte = neueKarte;
farbAuswahl.farbAuswahl(aktuelleKarte,regel,spielFeld);
geht = false;
//Hier wird die Karte dann geprüft ob es möglich ist diese zu legen
} else {
//Ist es nicht möglich die Karte zu legen, läuft der Loop hier weiter
while (geht == true){
kartelegen = false;
karteziehen = false;
while ((kartelegen || karteziehen) != true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
kartelegen = spielFeld.getkartelegen();
karteziehen = spielFeld.getkarteziehen();
//Diese Schleife prüft erneut ob der Spieler eine Karte Legen oder ziehen möchte
}
if (kartelegen == true){
neueKarte = spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielFeld.getKartenIndex());
//Entscheidet der Spieler sich für das legen der Karte wird wird die zu legende Karte erneut entnommen
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte, deck, spielerHand,lenght)) {
spielerHand.entferneKarteHand(spielFeld.getSpielerIndex(), spielFeld.getKartenIndex()+1, deck, zug);
aktuelleKarte = neueKarte;
farbAuswahl.farbAuswahl(aktuelleKarte,regel,spielFeld);
geht = false;
//Hier wird erneut geprüft ob die zu legende Karte legbar ist
}
}else if(karteziehen == true){
spielerHand.befuelleSpieleHand(spielFeld.getSpielerIndex(), deck, 1);
spielFeld.changeKarteziehen(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size()-1));
// Entscheidet der Spieler sich für das zihen der Karte wird ihm eine Karte hinzugefügt
synchronized (lock) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
while (geht == true) {
kartelegen = false;
karteziehen = false;
spielFeld.highLegen();
spielFeld.highBehalten();
while ((kartelegen || karteziehen) != true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
kartelegen = spielFeld.getneuekartelegen();
karteziehen = spielFeld.getneuekartebehalten();
//Hier wird entschieden ob der Spieler die neu gezogene Karte behalten möchte oder direkt legen möchte
}
spielFeld.highLegenundo();
spielFeld.highBehaltenundo();
if (karteziehen == true) {
spielFeld.changeKarteziehenundo();
geht = false;
//möchte der Spieler die Karte behalten passiert quasi nichts mehr
} else if (kartelegen == true) {
neueKarte = spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size() - 1);
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte, deck, spielerHand,lenght)) {
aktuelleKarte = neueKarte;
farbAuswahl.farbAuswahl(aktuelleKarte,regel,spielFeld);
spielerHand.entferneKarteHand(spielFeld.getSpielerIndex(), spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size(), deck, zug);
spielFeld.changeKarteziehenundo();
//Hier findet die Prüfung ob die Karte legbar ist statt
}
geht = false;
}
}
}
}
}
}else if (karteziehen == true){
geht = true;
spielerHand.befuelleSpieleHand(spielFeld.getSpielerIndex(), deck, 1);
spielFeld.changeKarteziehen(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size()-1));
synchronized (lock) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
while (geht == true) {
kartelegen = false;
karteziehen = false;
spielFeld.highBehalten();
spielFeld.highLegen();
while ((kartelegen || karteziehen) != true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
kartelegen = spielFeld.getneuekartelegen();
karteziehen = spielFeld.getneuekartebehalten();
//Hier wird erneut entschieden ob der Spieler die Karte behalten oder legen möchte
}
spielFeld.highBehaltenundo();
spielFeld.highLegenundo();
if (karteziehen == true) {
spielFeld.changeKarteziehenundo();
geht = false;
//Behält der Spieler die Karte, so passiert quasi nichts
} else if (kartelegen == true) {
UnoKarte neueKarte = spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).get(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size() - 1);
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte, deck, spielerHand,lenght)) {
aktuelleKarte = neueKarte;
farbAuswahl.farbAuswahl(aktuelleKarte,regel,spielFeld);
spielerHand.entferneKarteHand(spielFeld.getSpielerIndex(), spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size(), deck, zug);
spielFeld.changeKarteziehenundo();
//legt er sie wid sie überprüft oob dies auch möglich ist. Ist es nicht möglich behält der Spiler di Karte und der loop läuft weiter
}
geht = false;
}
}
}
if(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size() == 1){
//besitzt der Spieler nur noch eine Karte, so muss er uno "Sagen"
//Dies passiert indem der spieler inerhalb von 2.5 Sekunden auf uno drücken muss, sonst bekommt er eine Karte als Strafe
spielFeld.highUno();
boolean eineKarte = false;
try {
Thread.sleep(2500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
spielFeld.highUnoundo();
eineKarte = spielFeld.getUno();
if(eineKarte == true){
spielFeld.aktuelleKarte(aktuelleKarte);
spielFeld.Kartenausschalten();
continue;
}else {
spielerHand.befuelleSpieleHand(spielFeld.getSpielerIndex(), deck, 1);
}
}
//Besitzt ein Spiler keine Karten mehr, so wird der loop beendet und der EndScreen wird aufgerufen
if(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size() == 0){
spielFeld.beenden();
win = true;
Ende.EndScreen(spielerHand, spielFeld.getSpielerIndex());
}
spielFeld.changeKarteziehenundo();
spielFeld.aktuelleKarte(aktuelleKarte);
spielFeld.Kartenausschalten();
}
}
}
...@@ -2,58 +2,54 @@ import java.util.ArrayList; ...@@ -2,58 +2,54 @@ import java.util.ArrayList;
import java.util.Random; import java.util.Random;
public class SpielerHand{ public class SpielerHand{
private String[] spielerNamen; public String[] spielerNamen;
public ArrayList<ArrayList<UnoKarte>> spielerHaende; public ArrayList<ArrayList<UnoKarte>> spielerHaende;
public SpielerHand(String spieler1, String spieler2, String spieler3, String spieler4) { //1 public SpielerHand(int lenght, String[] PlayerNames) {
spielerNamen = new String[] {spieler1, spieler2, spieler3, spieler4}; // in spielerNamen werden alle spielernamen die übergeben worden gespeichert spielerNamen = new String[lenght];
spielerHaende = new ArrayList<ArrayList<UnoKarte>>(); // erstellen vom 2 dimesionalem array spielerHaende = new ArrayList<ArrayList<UnoKarte>>();
for (int i = 0; i < 4; i++) { for (int i = 0; i < lenght; i++) {
spielerHaende.add(new ArrayList<UnoKarte>()); //in dem einen array 4 weitere arrays erstellen spielerNamen[i] = PlayerNames[i];
spielerHaende.add(new ArrayList<UnoKarte>());
//Diese Methode erstellt zu jedem Spieler eine ArrayListe //Diese Methode erstellt zu jedem Spieler eine ArrayListe
} }
} }
public void fuegeKarteHinzu(int spielerIndex, UnoDeck deck, int kartenIndex) {//3 public void fuegeKarteHinzu(int spielerIndex, UnoDeck deck, int kartenIndex) {
UnoKarte karte = deck.get(kartenIndex); // karte wird erstellt mit der random n als kartenIndex UnoKarte karte = deck.get(kartenIndex);
spielerHaende.get(spielerIndex).add(karte); //spielerhand wird karte hinzugefügt spielerHaende.get(spielerIndex).add(karte);
deck.hand.remove(kartenIndex);//karte wird aus dem deck entfernt deck.hand.remove(kartenIndex);
//Diese Fuktion fügt karten in die Hand des jeweiligen spielers //Diese Fuktion fügt karten in die Hand des jeweiligen spielers
} }
public void entferneKarteHand(int spielerIndex, int kartenIdex, UnoDeck deck, int zug){//5 public void entferneKarteHand(int spielerIndex, int kartenIdex, UnoDeck deck, int zug){
Regelwerk regel = new Regelwerk(); Regelwerk regel = new Regelwerk();
kartenIdex = kartenIdex-1; // Abfrage auf der konsole ist von 1-7 aber im array ist es von 0-6 deswegen -1 kartenIdex = kartenIdex-1;
regel.aktuelleKarte(spielerHaende.get(spielerIndex).get(kartenIdex)); // aktuelle karte wird ausgegeben regel.aktuelleKarte(spielerHaende.get(spielerIndex).get(kartenIdex));
deck.hand.add(spielerHaende.get(spielerIndex).get(kartenIdex));//karte wird dem deck hinzugefügt deck.hand.add(spielerHaende.get(spielerIndex).get(kartenIdex));
spielerHaende.get(spielerIndex).remove(kartenIdex); //karte wird aus der hand des spielers entfernt spielerHaende.get(spielerIndex).remove(kartenIdex);
//Diese Methode entfernt eine Karte aus der Hand des Spielers //Diese Methode entfernt eine Karte aus der Hand des Spielers
} }
public void zeigeHaende(int indexSpieler) {//4 public void zeigeHaende(int indexSpieler) {
System.out.println(spielerNamen[indexSpieler] + ":"); int j = 1;
int j = 1;// Index der Karten auf der hand for (UnoKarte karte : spielerHaende.get(indexSpieler)) {
for (UnoKarte karte : spielerHaende.get(indexSpieler)) { System.out.print("Index: " + j +"\t");
System.out.print("Index: " + j +"\t"); j++;
System.out.println(karte);//Karte wird ausgegeben }
j++;//zahl wird erhöht für die nächste Karte
}
System.out.println();
//Diese Methode zeigt die Hand des Spielers //Diese Methode zeigt die Hand des Spielers
} }
public void befuelleSpieleHand(int spielerIndex, UnoDeck deck, int anzahl){//2 public void befuelleSpieleHand(int spielerIndex, UnoDeck deck, int anzahl){
Random rand = new Random(); // random zahl wird in rand gespeichert Random rand = new Random();
for (int i = 0; i < anzahl; i++) { for (int i = 0; i < anzahl; i++) {
int n = rand.nextInt(deck.hand.size()); // random zahl von 0 bis DeckSize int n = rand.nextInt(deck.hand.size());
fuegeKarteHinzu(spielerIndex, deck, n); // methode wird aufgerufen fuegeKarteHinzu(spielerIndex, deck, n);
} }
//Diese Methode gibt die Anzhal der Karten die der Spieler bekommen soll und wählt die zufähligge karte aus //Diese Methode gibt die Anzhal der Karten die der Spieler bekommen soll und wählt die zufähligge karte aus
} }
public void ranking(){//6 public void ranking(){
for (int i = 0; i < spielerHaende.size(); i++){ for (int i = 0; i < spielerHaende.size(); i++){
System.out.println(spielerNamen[i] + " Menge an Karten: " +spielerHaende.get(i).size());// spieler werden azsgegeben und die menge an karten in der jeweiligen hand aber nicht sortiert
} }
} }
} }
import java.util.Scanner;
public class UNO { public class UNO {
public static void main(String[] args) { public static void main(String[] args) {
//Die benötigten Klassen werden aufgerufen RunGame rungame = new RunGame();
UnoDeck deck = new UnoDeck(); rungame.Start();
Regelwerk regel = new Regelwerk();
Scanner scanner = new Scanner(System.in);
// Sobald start geschrieben wurde, wird das ganze spiel erstellt
System.out.println("Zum Starten, Start schreiben");
String start = scanner.nextLine();
if ("start".equals(start.toLowerCase())) {
deck.befuellen(); //Befüllt das deck
deck.mischeHand(); //mischehand mischt das Deck
regel.reihenfolgeFestlegen();
regel.wunschFestlegen(); //
//Spieler Namen Abfrage und Anzahl der Spieler
System.out.println("Kurze Information: mind. 2 Player max. 4 Player");
System.out.println("Enter Player Names:");
int index;
int PlayerAnzahl = 0;
String Antwort;
String PlayerNameInput;
String PlayerName[] = {"Joy Bot", "Note Bot", "Quick Bot", "CyBot"};
//Spielernamen werden befüllt
for (index = 0; index < 4; ) {
PlayerAnzahl++;
PlayerNameInput = scanner.nextLine();
PlayerName[index] = PlayerNameInput;
index++;
if (index >= 2) {
System.out.println("Sind das die Maximalen Spieler?");
Antwort = scanner.nextLine();
if ("ja".equals(Antwort.toLowerCase())) {
index = 4;
} else if (index != 4) {
System.out.println("Weitere Spieler:");
}
}
}
//Die Klasse Spielerhand wird aufgerufen und die PlayerName Paramentern werden übergeben
SpielerHand spielerHand = new SpielerHand(PlayerName[0], PlayerName[1], PlayerName[2], PlayerName[3]);
spielerHand.befuelleSpieleHand(0,deck,7);
spielerHand.befuelleSpieleHand(1,deck,7);
spielerHand.befuelleSpieleHand(2,deck,7);
spielerHand.befuelleSpieleHand(3,deck,7);
//GameLoop:
boolean win = false;
int zug = 1;
UnoKarte aktuelleKarte = regel.ersteKarte(deck,zug,deck.hand.size());
int legeKarte;
boolean geht = false; //Das boolean hilft bei der kontrolle, ob die Karte legbar ist!!!!
while (!win) {
//Zug wird gestartet, sobald start geschrieben wird
System.out.println("Zum Zug Starten, Start schreiben");
if("start" .equals(scanner.nextLine().toLowerCase())) {
System.out.println("Die Aktuelle Karte: \n" + aktuelleKarte);
zug++;
int spieler = regel.reihenfolge();
spielerHand.zeigeHaende(spieler);
System.out.println("legen oder ziehen");
//Karte Legen
if ("legen".equals(scanner.nextLine().toLowerCase())) {
System.out.println("Welche Karte?(Index)");
legeKarte = Integer.parseInt(scanner.nextLine());
UnoKarte neueKarte = spielerHand.spielerHaende.get(spieler).get(legeKarte-1);
geht = true;
//Wenn Karte legbar, wird Karte gelegt
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte,PlayerName, deck, spielerHand)) {
spielerHand.entferneKarteHand(spieler, legeKarte, deck, zug);
System.out.println("karte wurde gelegt");
aktuelleKarte =neueKarte;
geht = false;
//Karte kann nicht gelegt werden
}else {
while(geht == true) {
System.out.println("Die Aktuelle Karte: \n" + aktuelleKarte);
System.out.println("karte wurde nicht gelegt");
System.out.println("Weiterhin legen?(ja/nein)");
//Karte legen wenn ja geschrieben wird
if ("ja".equals(scanner.nextLine().toLowerCase())) {
System.out.println("Welche Karte?(Index)");
legeKarte = Integer.parseInt(scanner.nextLine());
neueKarte = spielerHand.spielerHaende.get(spieler).get(legeKarte-1);
//Wenn Karte legbar, wird Karte gelegt
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte,PlayerName,deck, spielerHand)) {
spielerHand.entferneKarteHand(spieler, legeKarte, deck, zug);
aktuelleKarte = neueKarte;
System.out.println("karte wurde gelegt");
geht = false;
}
// Karte ziehen wenn ja nicht geschrieben wird
} else {
spielerHand.befuelleSpieleHand(spieler, deck, 1);
System.out.println("Karte wurde gezogen");
geht = false;
}
}
}
//Karte Ziehen
} else {
spielerHand.befuelleSpieleHand(spieler, deck, 1);
int size = spielerHand.spielerHaende.get(spieler).size();
System.out.println("Die Aktuelle Karte: \n" + aktuelleKarte);
System.out.println("Gezogene Karte: " + spielerHand.spielerHaende.get(spieler).get(size - 1));
System.out.println("legen oder behalten?");
//Gezogene Karte legen
if ("legen".equals(scanner.nextLine().toLowerCase())) {
UnoKarte neueKarte = spielerHand.spielerHaende.get(spieler).get(size - 1);
System.out.println(neueKarte);
geht = true;
//Karte ist legbar
if (geht == regel.karteLegbar(aktuelleKarte, neueKarte,PlayerName, deck, spielerHand)) {
spielerHand.entferneKarteHand(spieler, size, deck, zug);
System.out.println("karte wurde gelegt");
aktuelleKarte =neueKarte;
geht = false;
//Karte ist nicht legbar
}else {
System.out.println("Karte wurde nicht gelegt");
}
}
}
//Wenn nur eine Karte vorhanden -> UNO
if(spielerHand.spielerHaende.get(spieler).size() == 1){
System.out.println("Möchtest du Uno sagen?");
//Wenn uno eingegeben wird -> weitermachen
if("uno" .equals(scanner.nextLine().toLowerCase())){
continue;
// Falls nicht -> 1 ziehen
}else {
spielerHand.befuelleSpieleHand(spieler, deck, 1);
}
}
//Spieler gewinnt wenn 0 Karten in der Hand ist und Spieler werden nach den Anzahl der Karten gewertet
if(spielerHand.spielerHaende.get(spieler).size() == 0){
spielerHand.ranking();
win = true;
}
}
}
}
} }
} }
...@@ -24,7 +24,6 @@ public class UnoDeck { ...@@ -24,7 +24,6 @@ public class UnoDeck {
public void zeigeDeck() { public void zeigeDeck() {
for (UnoKarte karte : hand) { for (UnoKarte karte : hand) {
System.out.println(karte);
//Diese Methode gibt das Array der UnoHand aus //Diese Methode gibt das Array der UnoHand aus
} }
} }
...@@ -79,7 +78,6 @@ public class UnoDeck { ...@@ -79,7 +78,6 @@ public class UnoDeck {
fuegeKarteHinzu(new UnoKarte(Farbe.Wild, Wert.Multicolor)); fuegeKarteHinzu(new UnoKarte(Farbe.Wild, Wert.Multicolor));
fuegeKarteHinzu(new UnoKarte(Farbe.Wild, Wert.Draw_Four)); fuegeKarteHinzu(new UnoKarte(Farbe.Wild, Wert.Draw_Four));
} }
//Diese Methode verbindet die Farben und die Zahlen der jeweiligen enums //Diese Methode verbindet die Farben und die Zahlen der jeweiligen enums
} }
} }
...@@ -29,4 +29,4 @@ enum Farbe { ...@@ -29,4 +29,4 @@ enum Farbe {
enum Wert { enum Wert {
Null, Eins, Zwei, Drei, Vier, Fuenf, Sechs, Sieben, Acht, Neun, Aussetzen, Richtungswechsel, Zwei_Ziehen, Multicolor, Draw_Four Null, Eins, Zwei, Drei, Vier, Fuenf, Sechs, Sieben, Acht, Neun, Aussetzen, Richtungswechsel, Zwei_Ziehen, Multicolor, Draw_Four
//Das sind die eigenschaften der jeweiligen Karten //Das sind die eigenschaften der jeweiligen Karten
} }
\ No newline at end of file
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
public class UnoSpielfeld extends JFrame {
private JPanel spielfeldPanel;
private JPanel spielerPanel;
private JPanel buttonsPanel;
private JScrollPane kartenScrollPane;
private JPanel kartenPanel;
private JPanel centerPanel;
public JButton zugButton;
public JButton unoButton;
public JButton karteLegen;
public JButton karteBehalten;
public JLabel kartenLabel;
public JButton zieheButton;
public JButton farbeundo = null;
public boolean zugStarten = false;
public boolean kartelegen = false;
public boolean karteziehen = false;
public boolean neuekartelegen = false;
public boolean neuekartebehalten = false;
public boolean uno = false;
public int Index;
public int spielerIndex = 0;
private int size = 0;
public Wert wert;
public Farbe farbe;
Object lock = null;
private ArrayList<JButton> spielerButton;
public UnoSpielfeld(UnoKarte aktuelleKarte, SpielerHand spilerhand, Regelwerk regel,Object lock1,int lenght) {
this.lock = lock1;
spielerButton = new ArrayList<JButton>();
size = lenght;
// Fenstereinstellungen
setTitle("Uno Spielfeld");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// Spielfeldpanel
spielfeldPanel = new JPanel(new BorderLayout());
add(spielfeldPanel, BorderLayout.CENTER);
// Kartenanzeige
kartenPanel = new JPanel();
kartenPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
kartenScrollPane = new JScrollPane(kartenPanel);
spielfeldPanel.add(kartenScrollPane, BorderLayout.SOUTH);
// Spielerliste
spielerPanel = new JPanel();
spielfeldPanel.add(spielerPanel, BorderLayout.EAST);
// Knöpfe
buttonsPanel = new JPanel();
spielfeldPanel.add(buttonsPanel, BorderLayout.WEST);
//Spielfeld
centerPanel = new JPanel();
spielfeldPanel.add(centerPanel, BorderLayout.CENTER);
// Knöpfe hinzufügen
zugStartenKnopf(spilerhand,regel);
unoKnopf();
buttonsPanel.setLayout(new BoxLayout(buttonsPanel, BoxLayout.Y_AXIS));
// Spieler hinzufügen
SpielerHinzufuegen(spilerhand);
karteBehalten();
//Karten ziehe Platz hinzufügen
zieheKarte();
ImageIcon kartenIcon = new ImageIcon("UnoKarten/BackSide.png"); // Passe den Pfad zum Kartenbild an
kartenLabel = new JLabel(kartenIcon);
centerPanel.add(kartenLabel);
karteLegen();
setSize(1200,700);
setVisible(true);
//Es wird das Spielfeld erstellt mit der größe 1200 x 700
}
public JButton createImageButton(String imagePath) {
ImageIcon icon = new ImageIcon(imagePath);
JButton button = new JButton(icon);
button.setBorderPainted(false);
button.setFocusPainted(false);
button.setContentAreaFilled(false);
return button;
}
public void SpielerHinzufuegen(SpielerHand spielerHand){
for(int j = 0; j < size ; j++){
int w = j;
int finalJ = j;
JButton spielerLabel = new JButton("Spieler " + (w + 1) + ": \t " + spielerHand.spielerNamen[j]);
spielerPanel.add(spielerLabel);
spielerButton.add(spielerLabel);
spielerLabel.setFont(new Font("Arial", Font.PLAIN, 20));
spielerLabel.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null,"Spieler " + spielerHand.spielerNamen[finalJ] + " besitzt " + spielerHand.spielerHaende.get(finalJ).size() + " Karten") ;
}
});
}
spielerPanel.setLayout(new BoxLayout(spielerPanel, BoxLayout.Y_AXIS));
//Es werden die Spieler angezeigt
//Beim drücken des Spielers öffnet sich ein Fenster mit der Anzahl der karten des Spielers
}
public void colorPlayer(int reihen){
if (farbeundo != null) {
farbeundo.setBackground(null);
}
JButton farbe = spielerButton.get(reihen);
farbeundo = farbe;
farbe.setBackground(Color.decode("#F2F723"));
//Es werde der Spieler der gerade am zug ist sichtbar angezeigt
}
public void karteBehalten(){
karteBehalten = new JButton("Behalten");
centerPanel.add(karteBehalten);
karteBehalten.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
neuekartebehalten = true;
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
neuekartebehalten = false;
}
});
//Der knopf zur Behalten der Karte und seine funktion werden Hier erstellt
}
public void karteLegen(){
karteLegen = new JButton("Legen");
centerPanel.add(karteLegen);
karteLegen.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
neuekartelegen = true;
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
neuekartelegen = false;
}
});
//Der knopf zum Legen der Karte und seine funktion werden Hier erstellt
}
public void zieheKarte(){
zieheButton = createImageButton("UnoKarten/BackSide.png");
centerPanel.add(zieheButton);
zieheButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
karteziehen = true;
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
synchronized (lock) {
lock.notify();
}
karteziehen = false;
}
});
//Der Stapel zum ziehen der Karte wird erstellt und bekommt das Bild von der Rückseite einer Uno Karte
}
public void changeKarteziehen(UnoKarte gezogeneKarte){
ImageIcon newIcon = new ImageIcon("UnoKarten/"+Bild(gezogeneKarte)+".png"); // Passe den Pfad zum Uno-Bild an
zieheButton.setIcon(newIcon);
//Diese funktion ändert das Bild des Stapels zu dem Bild welches der Spiler neu gezogen hat
}
public void changeKarteziehenundo(){
ImageIcon newIcon = new ImageIcon("UnoKarten/BackSide.png"); // Passe den Pfad zum Uno-Bild an
zieheButton.setIcon(newIcon);
//Diese Methode ändert das Bild wieder zur Rückseite einer Karte
}
public void aktuelleKarte(UnoKarte aktuelleKarte){
ImageIcon oldIcon = (ImageIcon) kartenLabel.getIcon();
kartenLabel.setIcon(null);
revalidate();
repaint();
ImageIcon newIcon = new ImageIcon("UnoKarten/" + Bild(aktuelleKarte) + ".png"); // Passe den Pfad zum Uno-Bild an
kartenLabel.setIcon(newIcon);
if(aktuelleKarte.getFarbe() == Farbe.Wild) {
if (wert == Wert.Multicolor) {
newIcon = new ImageIcon("UnoKarten/Wild_" + wert + "_" + farbe + ".png"); // Passe den Pfad zum Uno-Bild an
kartenLabel.setIcon(newIcon);
} else if (wert == Wert.Draw_Four) {
newIcon = new ImageIcon("UnoKarten/Wild_" + wert + "_" + farbe + ".png"); // Passe den Pfad zum Uno-Bild an
kartenLabel.setIcon(newIcon);
}
revalidate();
repaint();
}
//Es wird die Aktuelle Karte erstellt, welche zuletzt gelegt wurde
}
public void KarteHinzufuegen( SpielerHand spielerHand, int reihen){
spielerIndex = reihen;
int size = spielerHand.spielerHaende.get(reihen).size()-1;
for( int k = 0; k < 100; k++) {
}
kartenPanel.removeAll();
revalidate();
repaint();
for (int i = 0; i <= size; i++) {
JButton kartenButton = createImageButton("UnoKarten/"+Bild(spielerHand.spielerHaende.get(reihen).get(i))+".png"); // Passe den Pfad zum Kartenbild an
int finalI = i;
kartenButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
kartelegen = true;
Index = finalI;
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
kartelegen = false;
}
});
kartenPanel.add(kartenButton);
}
//es werden die Aktuellen Karten des Spilers der gerade am zug ist angezeigt
}
public void unoKnopf(){
unoButton = new JButton("Uno");
buttonsPanel.add(unoButton);
unoButton.setFont(new Font("Arial", Font.PLAIN, 20));
unoButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
uno = true;
try {
Thread.sleep(3000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
uno = false;
}
});
//Es wird ein Uno Knopf erstellt, mit seiner funktion
}
public void zugStartenKnopf(SpielerHand spielerHand, Regelwerk regel){
zugButton = new JButton("Zug Starten");
buttonsPanel.add(zugButton);
zugButton.setFont(new Font("Arial", Font.PLAIN, 20));
zugButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
zugStarten = true;
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
zugStarten = false;
}
});
//Es wird ein Knopf erstellt der den nächsten zug Starten lässt
}
public void Kartenausschalten(){
kartenPanel.removeAll();
revalidate();
repaint();
}
public void wechsleWunschKarte(Farbe wunschFarbe, Wert wunschWert){
farbe = wunschFarbe;
wert = wunschWert;
}
public void beenden(){
dispose();
}
public String Bild(UnoKarte aktuelleKarte){
Farbe farbe = aktuelleKarte.getFarbe();
Wert wert = aktuelleKarte.getWert();
String wort = farbe + "_" + wert;
return wort;
}
public void highUno(){
unoButton.setBackground(Color.decode("#F2F723"));
}
public void highUnoundo(){
unoButton.setBackground(null);
}
public void highBehalten(){
karteBehalten.setBackground(Color.decode("#F2F723"));
}
public void highBehaltenundo(){
karteBehalten.setBackground(null);
}
public void highLegen(){
karteLegen.setBackground(Color.decode("#F2F723"));
}
public void highLegenundo(){
karteLegen.setBackground(null);
}
public void highZugStarten(){
zugButton.setBackground(Color.decode("#F2F723"));
}
public void highZugStartenundo(){
zugButton.setBackground(null);
}
public boolean getzugStarten(){
return zugStarten;
}
public boolean getkartelegen(){
return kartelegen;
}
public boolean getkarteziehen(){
return karteziehen;
}
public boolean getneuekartelegen(){ return neuekartelegen; }
public boolean getneuekartebehalten(){ return neuekartebehalten; }
public boolean getUno(){ return uno; }
public int getKartenIndex(){ return Index; }
public int getSpielerIndex(){ return spielerIndex; }
}
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class farbAuswahl extends JFrame {
private JButton kartenAuswahlButton1 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton2 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton3 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton4 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton5 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton6 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton7 = createImageButton("UnoKarten/BackSide.png");
private JButton kartenAuswahlButton8 = createImageButton("UnoKarten/BackSide.png");
public void farbAuswahl(UnoKarte neueKarte,Regelwerk regel,UnoSpielfeld spielFeld){
if(neueKarte.getFarbe() == Farbe.Wild){
setTitle("Farbe Wählen");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
JPanel spielfeldPanel2 = new JPanel(new BorderLayout());
add(spielfeldPanel2, BorderLayout.CENTER);
JPanel centerPanel = new JPanel();
spielfeldPanel2.add(centerPanel, BorderLayout.CENTER);
centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
centerPanel.add(kartenAuswahlButton1);
centerPanel.add(kartenAuswahlButton2);
centerPanel.add(kartenAuswahlButton3);
centerPanel.add(kartenAuswahlButton4);
centerPanel.add(kartenAuswahlButton5);
centerPanel.add(kartenAuswahlButton6);
centerPanel.add(kartenAuswahlButton7);
centerPanel.add(kartenAuswahlButton8);
ImageIcon newIcon;
if(neueKarte.getWert() == Wert.Multicolor) {
centerPanel.remove(kartenAuswahlButton5);
centerPanel.remove(kartenAuswahlButton6);
centerPanel.remove(kartenAuswahlButton7);
centerPanel.remove(kartenAuswahlButton8);
for(int g = 0; g < 4; g++) {
switch (g){
case 0:
kartenAuswahlButton1.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Multicolor_Rot.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton1.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton1.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Rot);
spielFeld.wechsleWunschKarte(Farbe.Rot,Wert.Multicolor);
dispose();
}
});
break;
case 1:
kartenAuswahlButton2.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Multicolor_Blau.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton2.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Blau);
spielFeld.wechsleWunschKarte(Farbe.Blau,Wert.Multicolor);
dispose();
}
});
break;
case 2:
kartenAuswahlButton3.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Multicolor_Gruen.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton3.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton3.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Gruen);
spielFeld.wechsleWunschKarte(Farbe.Gruen,Wert.Multicolor);
dispose();
}
});
break;
case 3:
kartenAuswahlButton4.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Multicolor_Gelb.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton4.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton4.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Gelb);
spielFeld.wechsleWunschKarte(Farbe.Gelb,Wert.Multicolor);
dispose();
}
});
break;
default:
throw new IllegalStateException("Unexpected value: " + g);
}
}
}
else if(neueKarte.getWert() == Wert.Draw_Four) {
centerPanel.remove(kartenAuswahlButton1);
centerPanel.remove(kartenAuswahlButton2);
centerPanel.remove(kartenAuswahlButton3);
centerPanel.remove(kartenAuswahlButton4);
for(int g = 0; g < 4; g++) {
switch (g){
case 0:
kartenAuswahlButton5.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Draw_Four_Rot.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton5.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton5.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Rot);
spielFeld.wechsleWunschKarte(Farbe.Rot,Wert.Draw_Four);
dispose();
}
});
break;
case 1:
kartenAuswahlButton6.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Draw_Four_Blau.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton6.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton6.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Blau);
spielFeld.wechsleWunschKarte(Farbe.Blau,Wert.Draw_Four);
dispose();
}
});
break;
case 2:
kartenAuswahlButton7.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Draw_Four_Gruen.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton7.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton7.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Gruen);
spielFeld.wechsleWunschKarte(Farbe.Gruen,Wert.Draw_Four);
dispose();
}
});
break;
case 3:
kartenAuswahlButton8.setIcon(null);
newIcon = new ImageIcon("UnoKarten/Wild_Draw_Four_Gelb.png"); // Passe den Pfad zum Uno-Bild an
kartenAuswahlButton8.setIcon(newIcon);
revalidate();
repaint();
kartenAuswahlButton8.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
regel.color.add(Farbe.Gelb);
spielFeld.wechsleWunschKarte(Farbe.Gelb,Wert.Draw_Four);
dispose();
}
});
break;
default:
throw new IllegalStateException("Unexpected value: " + g);
}
}
}
revalidate();
repaint();
pack();
setVisible(true);
}
//Es wird ein Fenster geöffnet, indem man seine wunschfarbe Auswählen kann
//Manchmal werden nicht alle Bilder geladen, dann muss man mit der Maus drüber fahren!!!!!!
}
public JButton createImageButton(String imagePath) {
ImageIcon icon = new ImageIcon(imagePath);
JButton button = new JButton(icon);
button.setBorderPainted(false);
button.setFocusPainted(false);
button.setContentAreaFilled(false);
return button;
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment