diff --git a/UnoKarten/BackSide.png b/UnoKarten/BackSide.png
new file mode 100644
index 0000000000000000000000000000000000000000..2125f63e7b6bd810d90df73e6f45b6f810f0e106
Binary files /dev/null and b/UnoKarten/BackSide.png differ
diff --git a/UnoKarten/Blau_Acht.png b/UnoKarten/Blau_Acht.png
new file mode 100644
index 0000000000000000000000000000000000000000..618ad57905dd07121e053b156e666bc28b90121d
Binary files /dev/null and b/UnoKarten/Blau_Acht.png differ
diff --git a/UnoKarten/Blau_Aussetzen.png b/UnoKarten/Blau_Aussetzen.png
new file mode 100644
index 0000000000000000000000000000000000000000..edaf2c9ec4cad3e72c9c45028b59047a0dd548dc
Binary files /dev/null and b/UnoKarten/Blau_Aussetzen.png differ
diff --git a/UnoKarten/Blau_Drei.png b/UnoKarten/Blau_Drei.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5b8a065bc912755e1ec1dc79f72193714defa5a
Binary files /dev/null and b/UnoKarten/Blau_Drei.png differ
diff --git a/UnoKarten/Blau_Eins.png b/UnoKarten/Blau_Eins.png
new file mode 100644
index 0000000000000000000000000000000000000000..e2727b9c9c8e2fc06bc023633e2d43f2ef37688d
Binary files /dev/null and b/UnoKarten/Blau_Eins.png differ
diff --git a/UnoKarten/Blau_Fuenf.png b/UnoKarten/Blau_Fuenf.png
new file mode 100644
index 0000000000000000000000000000000000000000..b2088562debd017e63481982f3bb73653e47a7a0
Binary files /dev/null and b/UnoKarten/Blau_Fuenf.png differ
diff --git a/UnoKarten/Blau_Neun.png b/UnoKarten/Blau_Neun.png
new file mode 100644
index 0000000000000000000000000000000000000000..16045bcabf928f4540ebeb49091c90b9019d83b4
Binary files /dev/null and b/UnoKarten/Blau_Neun.png differ
diff --git a/UnoKarten/Blau_Null.png b/UnoKarten/Blau_Null.png
new file mode 100644
index 0000000000000000000000000000000000000000..f6d4104a9640eafdd9f334ca772e00fd902acae9
Binary files /dev/null and b/UnoKarten/Blau_Null.png differ
diff --git a/UnoKarten/Blau_Richtungswechsel.png b/UnoKarten/Blau_Richtungswechsel.png
new file mode 100644
index 0000000000000000000000000000000000000000..73cacff1c1d014b881e46ec1dc5cf7e75c46f07c
Binary files /dev/null and b/UnoKarten/Blau_Richtungswechsel.png differ
diff --git a/UnoKarten/Blau_Sechs.png b/UnoKarten/Blau_Sechs.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b122cdeccbfabf5a651a429c86b21750aa360d3
Binary files /dev/null and b/UnoKarten/Blau_Sechs.png differ
diff --git a/UnoKarten/Blau_Sieben.png b/UnoKarten/Blau_Sieben.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea4a21a2c184995f65cc23d6c340648d4cb0fe05
Binary files /dev/null and b/UnoKarten/Blau_Sieben.png differ
diff --git a/UnoKarten/Blau_Vier.png b/UnoKarten/Blau_Vier.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5ca2e0cac6906254248fc81799a22cd484b164c
Binary files /dev/null and b/UnoKarten/Blau_Vier.png differ
diff --git a/UnoKarten/Blau_Zwei.png b/UnoKarten/Blau_Zwei.png
new file mode 100644
index 0000000000000000000000000000000000000000..cac182ec3ea051490909c096640ac142728df548
Binary files /dev/null and b/UnoKarten/Blau_Zwei.png differ
diff --git a/UnoKarten/Blau_Zwei_Ziehen.png b/UnoKarten/Blau_Zwei_Ziehen.png
new file mode 100644
index 0000000000000000000000000000000000000000..a842698b25e95d2ab86b83b4aa9e60f96d9610d4
Binary files /dev/null and b/UnoKarten/Blau_Zwei_Ziehen.png differ
diff --git a/UnoKarten/Gelb_Acht.png b/UnoKarten/Gelb_Acht.png
new file mode 100644
index 0000000000000000000000000000000000000000..59ee52f46b173f630098b2c22429015a6c5eabf4
Binary files /dev/null and b/UnoKarten/Gelb_Acht.png differ
diff --git a/UnoKarten/Gelb_Aussetzen.png b/UnoKarten/Gelb_Aussetzen.png
new file mode 100644
index 0000000000000000000000000000000000000000..f65851679d210a2e17571e7f52d8e0807b75e553
Binary files /dev/null and b/UnoKarten/Gelb_Aussetzen.png differ
diff --git a/UnoKarten/Gelb_Drei.png b/UnoKarten/Gelb_Drei.png
new file mode 100644
index 0000000000000000000000000000000000000000..f5891316c7cdd51def9fe0ca5fbccf40b15c073c
Binary files /dev/null and b/UnoKarten/Gelb_Drei.png differ
diff --git a/UnoKarten/Gelb_Eins.png b/UnoKarten/Gelb_Eins.png
new file mode 100644
index 0000000000000000000000000000000000000000..fca8c7d37a7475296918e2b9dc8fe791b2bf5d77
Binary files /dev/null and b/UnoKarten/Gelb_Eins.png differ
diff --git a/UnoKarten/Gelb_Fuenf.png b/UnoKarten/Gelb_Fuenf.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a87c885f3cfa38d49c4f9544d5729f145b55fdd
Binary files /dev/null and b/UnoKarten/Gelb_Fuenf.png differ
diff --git a/UnoKarten/Gelb_Neun.png b/UnoKarten/Gelb_Neun.png
new file mode 100644
index 0000000000000000000000000000000000000000..de9516f0bc36016fc50d2ba99ba2976e10a81198
Binary files /dev/null and b/UnoKarten/Gelb_Neun.png differ
diff --git a/UnoKarten/Gelb_Null.png b/UnoKarten/Gelb_Null.png
new file mode 100644
index 0000000000000000000000000000000000000000..24b7ace2013acb99b94c44eeec41d6627b994223
Binary files /dev/null and b/UnoKarten/Gelb_Null.png differ
diff --git a/UnoKarten/Gelb_Richtungswechsel.png b/UnoKarten/Gelb_Richtungswechsel.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd6f345e53893d323c61c18f7a8564cea3bd7aec
Binary files /dev/null and b/UnoKarten/Gelb_Richtungswechsel.png differ
diff --git a/UnoKarten/Gelb_Sechs.png b/UnoKarten/Gelb_Sechs.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b79184586504d7fecacedbe871aa2957fa4f817
Binary files /dev/null and b/UnoKarten/Gelb_Sechs.png differ
diff --git a/UnoKarten/Gelb_Sieben.png b/UnoKarten/Gelb_Sieben.png
new file mode 100644
index 0000000000000000000000000000000000000000..679a0bcff747015784f39a7319849efdba49c006
Binary files /dev/null and b/UnoKarten/Gelb_Sieben.png differ
diff --git a/UnoKarten/Gelb_Vier.png b/UnoKarten/Gelb_Vier.png
new file mode 100644
index 0000000000000000000000000000000000000000..30846caaf59c23f24db402319d853641facf03d7
Binary files /dev/null and b/UnoKarten/Gelb_Vier.png differ
diff --git a/UnoKarten/Gelb_Zwei.png b/UnoKarten/Gelb_Zwei.png
new file mode 100644
index 0000000000000000000000000000000000000000..49331815053b48f81dafe02e91d7f7eeda34a93b
Binary files /dev/null and b/UnoKarten/Gelb_Zwei.png differ
diff --git a/UnoKarten/Gelb_Zwei_Ziehen.png b/UnoKarten/Gelb_Zwei_Ziehen.png
new file mode 100644
index 0000000000000000000000000000000000000000..a88e5fae5f32efc21676adeae77b9434da919286
Binary files /dev/null and b/UnoKarten/Gelb_Zwei_Ziehen.png differ
diff --git a/UnoKarten/Gruen_Acht.png b/UnoKarten/Gruen_Acht.png
new file mode 100644
index 0000000000000000000000000000000000000000..ff0dfd9f0384964ce232789d6f6e8bd12497e394
Binary files /dev/null and b/UnoKarten/Gruen_Acht.png differ
diff --git a/UnoKarten/Gruen_Aussetzen.png b/UnoKarten/Gruen_Aussetzen.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ec908e8dcdc54709ef3f4b65c9c8733f17ca495
Binary files /dev/null and b/UnoKarten/Gruen_Aussetzen.png differ
diff --git a/UnoKarten/Gruen_Drei.png b/UnoKarten/Gruen_Drei.png
new file mode 100644
index 0000000000000000000000000000000000000000..0dcb238e18399400d330da5084d5fc9a40ac5c0e
Binary files /dev/null and b/UnoKarten/Gruen_Drei.png differ
diff --git a/UnoKarten/Gruen_Eins.png b/UnoKarten/Gruen_Eins.png
new file mode 100644
index 0000000000000000000000000000000000000000..91a37bc6e304edd572ff287d9e67cb3ff2bbaa77
Binary files /dev/null and b/UnoKarten/Gruen_Eins.png differ
diff --git a/UnoKarten/Gruen_Fuenf.png b/UnoKarten/Gruen_Fuenf.png
new file mode 100644
index 0000000000000000000000000000000000000000..06ffb7798a55467a3a4c9c51be5eac1694047863
Binary files /dev/null and b/UnoKarten/Gruen_Fuenf.png differ
diff --git a/UnoKarten/Gruen_Neun.png b/UnoKarten/Gruen_Neun.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d59e512a54c0ab8c02b54a3ea907a6e8891fa3b
Binary files /dev/null and b/UnoKarten/Gruen_Neun.png differ
diff --git a/UnoKarten/Gruen_Null.png b/UnoKarten/Gruen_Null.png
new file mode 100644
index 0000000000000000000000000000000000000000..70455ec50fc0009fbfaff7dbb50c9cfec669db3e
Binary files /dev/null and b/UnoKarten/Gruen_Null.png differ
diff --git a/UnoKarten/Gruen_Richtungswechsel.png b/UnoKarten/Gruen_Richtungswechsel.png
new file mode 100644
index 0000000000000000000000000000000000000000..3988403b330bfc2f04d2d445c4ca46a8b7cf9be8
Binary files /dev/null and b/UnoKarten/Gruen_Richtungswechsel.png differ
diff --git a/UnoKarten/Gruen_Sechs.png b/UnoKarten/Gruen_Sechs.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b11d780b668739e94d27e0025d083fe364b6cef
Binary files /dev/null and b/UnoKarten/Gruen_Sechs.png differ
diff --git a/UnoKarten/Gruen_Sieben.png b/UnoKarten/Gruen_Sieben.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd033968373a8debb168d2fc51a669a53b9575fe
Binary files /dev/null and b/UnoKarten/Gruen_Sieben.png differ
diff --git a/UnoKarten/Gruen_Vier.png b/UnoKarten/Gruen_Vier.png
new file mode 100644
index 0000000000000000000000000000000000000000..dd338a192f6bbdcaa76dec281493271acc3cc5de
Binary files /dev/null and b/UnoKarten/Gruen_Vier.png differ
diff --git a/UnoKarten/Gruen_Zwei.png b/UnoKarten/Gruen_Zwei.png
new file mode 100644
index 0000000000000000000000000000000000000000..2fdb99a1d23174f5a47fcef2b5c10d79837e25d7
Binary files /dev/null and b/UnoKarten/Gruen_Zwei.png differ
diff --git a/UnoKarten/Gruen_Zwei_Ziehen.png b/UnoKarten/Gruen_Zwei_Ziehen.png
new file mode 100644
index 0000000000000000000000000000000000000000..9b12ac0188c4a175a9fdddfc61e5bd6b50e75db2
Binary files /dev/null and b/UnoKarten/Gruen_Zwei_Ziehen.png differ
diff --git a/UnoKarten/Rot_Acht.png b/UnoKarten/Rot_Acht.png
new file mode 100644
index 0000000000000000000000000000000000000000..ff6f50db7d44a9439e33b622d80a233bb9c0e562
Binary files /dev/null and b/UnoKarten/Rot_Acht.png differ
diff --git a/UnoKarten/Rot_Aussetzen.png b/UnoKarten/Rot_Aussetzen.png
new file mode 100644
index 0000000000000000000000000000000000000000..9eff9fd5ae335e1ce5b416f0b88c48fe4618faf8
Binary files /dev/null and b/UnoKarten/Rot_Aussetzen.png differ
diff --git a/UnoKarten/Rot_Drei.png b/UnoKarten/Rot_Drei.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b3d54236c328ed01c4223b4007c76ba55ba548f
Binary files /dev/null and b/UnoKarten/Rot_Drei.png differ
diff --git a/UnoKarten/Rot_Eins.png b/UnoKarten/Rot_Eins.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b1992ac725f9a9402597002b782af912271d642
Binary files /dev/null and b/UnoKarten/Rot_Eins.png differ
diff --git a/UnoKarten/Rot_Fuenf.png b/UnoKarten/Rot_Fuenf.png
new file mode 100644
index 0000000000000000000000000000000000000000..c15d1733b5bb85d5eb4e036d3fa15ecda71a3362
Binary files /dev/null and b/UnoKarten/Rot_Fuenf.png differ
diff --git a/UnoKarten/Rot_Neun.png b/UnoKarten/Rot_Neun.png
new file mode 100644
index 0000000000000000000000000000000000000000..7dbc00a2e272eb2e98c882105e4e95e00661bcb9
Binary files /dev/null and b/UnoKarten/Rot_Neun.png differ
diff --git a/UnoKarten/Rot_Null.png b/UnoKarten/Rot_Null.png
new file mode 100644
index 0000000000000000000000000000000000000000..af31862ed7a5b5c132840d1162649dd1f8f8607c
Binary files /dev/null and b/UnoKarten/Rot_Null.png differ
diff --git a/UnoKarten/Rot_Richtungswechsel.png b/UnoKarten/Rot_Richtungswechsel.png
new file mode 100644
index 0000000000000000000000000000000000000000..c35661f956b34543f97fff8ff5ac8bf8d7baa7ae
Binary files /dev/null and b/UnoKarten/Rot_Richtungswechsel.png differ
diff --git a/UnoKarten/Rot_Sechs.png b/UnoKarten/Rot_Sechs.png
new file mode 100644
index 0000000000000000000000000000000000000000..3dc6458d4198cdf2cefece1e8bb4cd17ca09f8ff
Binary files /dev/null and b/UnoKarten/Rot_Sechs.png differ
diff --git a/UnoKarten/Rot_Sieben.png b/UnoKarten/Rot_Sieben.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a177966d97386ccf91c088caae2645a275a9204
Binary files /dev/null and b/UnoKarten/Rot_Sieben.png differ
diff --git a/UnoKarten/Rot_Vier.png b/UnoKarten/Rot_Vier.png
new file mode 100644
index 0000000000000000000000000000000000000000..f156221512c7e041f917a9d344375eb9038e99f0
Binary files /dev/null and b/UnoKarten/Rot_Vier.png differ
diff --git a/UnoKarten/Rot_Zwei.png b/UnoKarten/Rot_Zwei.png
new file mode 100644
index 0000000000000000000000000000000000000000..96c9dd8ef0e36b8df739cbaee52a110860dfc96b
Binary files /dev/null and b/UnoKarten/Rot_Zwei.png differ
diff --git a/UnoKarten/Rot_Zwei_Ziehen.png b/UnoKarten/Rot_Zwei_Ziehen.png
new file mode 100644
index 0000000000000000000000000000000000000000..15b07c50d138526f40d84d5387985369f0dcf784
Binary files /dev/null and b/UnoKarten/Rot_Zwei_Ziehen.png differ
diff --git a/UnoKarten/Wild_Draw_Four.png b/UnoKarten/Wild_Draw_Four.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba0fcfdeda12a81a1b15af32598ae8b7c9a132ce
Binary files /dev/null and b/UnoKarten/Wild_Draw_Four.png differ
diff --git a/UnoKarten/Wild_Draw_Four_Blau.png b/UnoKarten/Wild_Draw_Four_Blau.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac889e98fe2a26fe5986c25d6f9f800cec804712
Binary files /dev/null and b/UnoKarten/Wild_Draw_Four_Blau.png differ
diff --git a/UnoKarten/Wild_Draw_Four_Gelb.png b/UnoKarten/Wild_Draw_Four_Gelb.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1bb23510524be5cde498a577941aa0828652189
Binary files /dev/null and b/UnoKarten/Wild_Draw_Four_Gelb.png differ
diff --git a/UnoKarten/Wild_Draw_Four_Gruen.png b/UnoKarten/Wild_Draw_Four_Gruen.png
new file mode 100644
index 0000000000000000000000000000000000000000..7e36bde9354e72b0c730926a143b8183197521ce
Binary files /dev/null and b/UnoKarten/Wild_Draw_Four_Gruen.png differ
diff --git a/UnoKarten/Wild_Draw_Four_Rot.png b/UnoKarten/Wild_Draw_Four_Rot.png
new file mode 100644
index 0000000000000000000000000000000000000000..673623685559104f65ca98c1f1c2a51e4b2ec168
Binary files /dev/null and b/UnoKarten/Wild_Draw_Four_Rot.png differ
diff --git a/UnoKarten/Wild_Multicolor.png b/UnoKarten/Wild_Multicolor.png
new file mode 100644
index 0000000000000000000000000000000000000000..730a85696b53f315fd0386084dcd40376833b425
Binary files /dev/null and b/UnoKarten/Wild_Multicolor.png differ
diff --git a/UnoKarten/Wild_Multicolor_Blau.png b/UnoKarten/Wild_Multicolor_Blau.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b9971e04538a0f4801c99a2db84c00533757a79
Binary files /dev/null and b/UnoKarten/Wild_Multicolor_Blau.png differ
diff --git a/UnoKarten/Wild_Multicolor_Gelb.png b/UnoKarten/Wild_Multicolor_Gelb.png
new file mode 100644
index 0000000000000000000000000000000000000000..19e99259ebf768aafcb200bd9bd684ac39c7e5b9
Binary files /dev/null and b/UnoKarten/Wild_Multicolor_Gelb.png differ
diff --git a/UnoKarten/Wild_Multicolor_Gruen.png b/UnoKarten/Wild_Multicolor_Gruen.png
new file mode 100644
index 0000000000000000000000000000000000000000..ccb32cd59d42a77fe3a1e97870f8a87b65dcfe2f
Binary files /dev/null and b/UnoKarten/Wild_Multicolor_Gruen.png differ
diff --git a/UnoKarten/Wild_Multicolor_Rot.png b/UnoKarten/Wild_Multicolor_Rot.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb3421943cbec5266435909785d2fe8fe57da778
Binary files /dev/null and b/UnoKarten/Wild_Multicolor_Rot.png differ
diff --git a/src/EndScreen.java b/src/EndScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..16377e183e4bb9cfb0f075ea59e8ef1ff3be7246
--- /dev/null
+++ b/src/EndScreen.java
@@ -0,0 +1,66 @@
+
+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
+}
diff --git a/src/PlayerNamesInput.java b/src/PlayerNamesInput.java
new file mode 100644
index 0000000000000000000000000000000000000000..03a1279a4c324e8e29970ec85d61255cb2dca5cb
--- /dev/null
+++ b/src/PlayerNamesInput.java
@@ -0,0 +1,147 @@
+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;
+ }
+
+}
diff --git a/src/Regelwerk.java b/src/Regelwerk.java
index b56445195bc6a1afa0490ab80ca03aed4d3d10c1..58cfbf7d56511d676a735c6aef6430a884b23177 100644
--- a/src/Regelwerk.java
+++ b/src/Regelwerk.java
@@ -8,34 +8,33 @@ public class Regelwerk {
public ArrayList<Integer> reihenfolge;
public ArrayList<Farbe> color;
- public void reihenfolgeFestlegen() { // spieler index in Array gespeichert
+ public void reihenfolgeFestlegen(int length) {
reihenfolge = new ArrayList<Integer>();
- reihenfolge.add(0, 0); // index , value
- reihenfolge.add(1, 1);
- reihenfolge.add(2, 2);
- reihenfolge.add(3, 3);
+ for(int i = 0; i < length; i++) {
+ reihenfolge.add(i,i);
+ }
}
public UnoKarte ersteKarte(UnoDeck hand, int zug, int anzahl) {
if (zug == 1) {
- Random rand = new Random(); // random zahl wird generriert
- int n = rand.nextInt(anzahl); // random zahl von 0 bis DeckSize wird in n gespeichert
- UnoKarte aktuellekarte = hand.get(n); // n wird in aktuelle karte gespeichert
+ Random rand = new Random();
+ int n = rand.nextInt(anzahl);
+ UnoKarte aktuellekarte = hand.get(n);
System.out.println("Die Aktuelle Karte:");
- System.out.println(aktuellekarte); // ausgabe
+ System.out.println(aktuellekarte);
return aktuellekarte;
}
return hand.get(1);
}
public void aktuelleKarte(UnoKarte letzteKarte) {
System.out.println("Die Aktuelle Karte:");
- System.out.println(letzteKarte); // ausgabe aktuelle karte
+ System.out.println(letzteKarte);
}
public int reihenfolge() {
- int aktuell = reihenfolge.get(0); // erster spieler wird gespeichert
- reihenfolge.remove(0); //erster spieler wird geklöscht
- reihenfolge.add(aktuell); // erster spieler wird am ende des arrays eingefügt
+ int aktuell = reihenfolge.get(0);
+ reihenfolge.remove(0);
+ reihenfolge.add(aktuell);
return aktuell;
}
public void wunschFestlegen(){
@@ -43,91 +42,90 @@ public class Regelwerk {
color.add(0,Farbe.Wild);
}
- public boolean karteLegbar(UnoKarte aktuellekarte, UnoKarte neueKarte, String PlayerName[], UnoDeck deck, SpielerHand spielerHand) {
- if (color.size() == 2) {// wird erst bei einem kartenWunsch genutzt
- System.out.println("Wunchfarbe: " + color.get(1));
- 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); // karte wird gelegt
- return Lege(aktuellekarte, neueKarte, PlayerName, deck, spielerHand);
+ public boolean karteLegbar(UnoKarte aktuellekarte, UnoKarte neueKarte, UnoDeck deck, SpielerHand spielerHand, int lenght) {
+ if (color.size() == 2) {
+ if ((color.get(1) == neueKarte.getFarbe()) || (color.get(0) == neueKarte.getFarbe())) {
+ color.remove(1);
+ return Lege(aktuellekarte, neueKarte,deck, spielerHand,lenght);
}else {
return false;
}
- } else { // wird aufgerufen wenn keine wunschfarbe existiert
- return Lege(aktuellekarte, neueKarte, PlayerName, deck, spielerHand);
+ } else {
+ return Lege(aktuellekarte, neueKarte, deck, spielerHand,lenght);
}
}
- public boolean Lege(UnoKarte aktuellekarte, UnoKarte neueKarte,String PlayerName[], UnoDeck deck, SpielerHand spielerHand){
- if ((aktuellekarte.getFarbe() == neueKarte.getFarbe()) || (Farbe.Wild == neueKarte.getFarbe()) || ((aktuellekarte.getFarbe() == Farbe.Wild) && (Farbe.Wild != neueKarte.getFarbe()))) {// Farb kontrolle -> Bedingungen ob legbar oder nicht
+ 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()))) {
if (neueKarte.getWert() == Wert.Zwei_Ziehen) {
- Ziehen(PlayerName, deck, 2, spielerHand);
+ Ziehen(deck, 2, spielerHand);
} else if (neueKarte.getWert() == Wert.Aussetzen) {
aussetzen();
} else if (neueKarte.getWert() == Wert.Richtungswechsel) {
- richtungaendern();
+ richtungaendern(lenght);
} else if (neueKarte.getWert() == Wert.Multicolor) {
- wunschFarbe();
+ //wunschFarbe();
}else if (neueKarte.getWert() == Wert.Draw_Four) {
- wunschFarbe();
- Ziehen(PlayerName, deck, 4, spielerHand);
+ //wunschFarbe();
+ Ziehen(deck, 4, spielerHand);
}
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) {
- Ziehen(PlayerName, deck, 2, spielerHand);
+ Ziehen(deck, 2, spielerHand);
} else if (neueKarte.getWert() == Wert.Aussetzen) {
aussetzen();
} else if (neueKarte.getWert() == Wert.Richtungswechsel) {
- richtungaendern();
+ richtungaendern(lenght);
}else if (neueKarte.getWert() == Wert.Multicolor) {
- wunschFarbe();
+ //wunschFarbe();
}else if (neueKarte.getWert() == Wert.Draw_Four) {
- wunschFarbe();
- Ziehen(PlayerName, deck, 4, spielerHand);
+ //wunschFarbe();
+ Ziehen(deck, 4, spielerHand);
}
return true;
}
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);
spielerHand.befuelleSpieleHand(spieler, deck, anzahl);
}
public void aussetzen(){
- int aktuell = reihenfolge.get(0);// spieler wird in aktuell gespeichert
- reihenfolge.remove(0);// nächster spieler wird gelöscht
- reihenfolge.add(aktuell);// wird am ende des arrays hinzugefügt
+ int aktuell = reihenfolge.get(0);
+ reihenfolge.remove(0);
+ reihenfolge.add(aktuell);
}
- public void richtungaendern(){
- int [] richtungswechsel = new int[4];// neuer array richtungswechsel
+ public void richtungaendern(int lenght){
+ int [] richtungswechsel = new int[lenght];
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();
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--){
- reihenfolge.add(richtungswechsel[i]);// werte werden umgekehrt in den alten array wieder eingefügt
+ for(int i = size-1; i >= 0; i--){
+ reihenfolge.add(richtungswechsel[i]);
}
- int zwischen = reihenfolge.get(0); // erster spieler wird in zwischen gespeichert
- reihenfolge.remove(0);// erster spieler wird gelöscht
- reihenfolge.add(zwischen);// erster spieler wird im array neu eingefügtr aber hinten
+ int zwischen = reihenfolge.get(0);
+ reihenfolge.remove(0);
+ reihenfolge.add(zwischen);
}
public void wunschFarbe(){
System.out.println("Welche Farbe möchteswt du?(Gruen, Blau, Gelb, Rot)");
switch (scanner.nextLine().toLowerCase()){
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;
case "blau":
- color.add(Farbe.Blau);// "
+ color.add(Farbe.Blau);
break;
case "gelb":
- color.add(Farbe.Gelb);// "
+ color.add(Farbe.Gelb);
break;
case "rot":
- color.add(Farbe.Rot);// "
+ color.add(Farbe.Rot);
break;
}
}
diff --git a/src/RunGame.java b/src/RunGame.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fd1c82fde4cb809bd43faf2e152376bbe3b3403
--- /dev/null
+++ b/src/RunGame.java
@@ -0,0 +1,278 @@
+
+
+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();
+ }
+ }
+}
diff --git a/src/SpielerHand.java b/src/SpielerHand.java
index fae31a8148a5d2452cb62b29ea86cb104a3a4b0f..b439f6274378b345f18d00576524a09ec389aec1 100644
--- a/src/SpielerHand.java
+++ b/src/SpielerHand.java
@@ -2,58 +2,54 @@ import java.util.ArrayList;
import java.util.Random;
public class SpielerHand{
- private String[] spielerNamen;
+ public String[] spielerNamen;
public ArrayList<ArrayList<UnoKarte>> spielerHaende;
- public SpielerHand(String spieler1, String spieler2, String spieler3, String spieler4) { //1
- spielerNamen = new String[] {spieler1, spieler2, spieler3, spieler4}; // in spielerNamen werden alle spielernamen die übergeben worden gespeichert
- spielerHaende = new ArrayList<ArrayList<UnoKarte>>(); // erstellen vom 2 dimesionalem array
- for (int i = 0; i < 4; i++) {
- spielerHaende.add(new ArrayList<UnoKarte>()); //in dem einen array 4 weitere arrays erstellen
+ public SpielerHand(int lenght, String[] PlayerNames) {
+ spielerNamen = new String[lenght];
+ spielerHaende = new ArrayList<ArrayList<UnoKarte>>();
+ for (int i = 0; i < lenght; i++) {
+ spielerNamen[i] = PlayerNames[i];
+ spielerHaende.add(new ArrayList<UnoKarte>());
//Diese Methode erstellt zu jedem Spieler eine ArrayListe
}
}
- public void fuegeKarteHinzu(int spielerIndex, UnoDeck deck, int kartenIndex) {//3
- UnoKarte karte = deck.get(kartenIndex); // karte wird erstellt mit der random n als kartenIndex
- spielerHaende.get(spielerIndex).add(karte); //spielerhand wird karte hinzugefügt
- deck.hand.remove(kartenIndex);//karte wird aus dem deck entfernt
+ public void fuegeKarteHinzu(int spielerIndex, UnoDeck deck, int kartenIndex) {
+ UnoKarte karte = deck.get(kartenIndex);
+ spielerHaende.get(spielerIndex).add(karte);
+ deck.hand.remove(kartenIndex);
//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();
- kartenIdex = kartenIdex-1; // Abfrage auf der konsole ist von 1-7 aber im array ist es von 0-6 deswegen -1
- regel.aktuelleKarte(spielerHaende.get(spielerIndex).get(kartenIdex)); // aktuelle karte wird ausgegeben
- deck.hand.add(spielerHaende.get(spielerIndex).get(kartenIdex));//karte wird dem deck hinzugefügt
- spielerHaende.get(spielerIndex).remove(kartenIdex); //karte wird aus der hand des spielers entfernt
+ kartenIdex = kartenIdex-1;
+ regel.aktuelleKarte(spielerHaende.get(spielerIndex).get(kartenIdex));
+ deck.hand.add(spielerHaende.get(spielerIndex).get(kartenIdex));
+ spielerHaende.get(spielerIndex).remove(kartenIdex);
//Diese Methode entfernt eine Karte aus der Hand des Spielers
}
- public void zeigeHaende(int indexSpieler) {//4
- System.out.println(spielerNamen[indexSpieler] + ":");
- int j = 1;// Index der Karten auf der hand
- for (UnoKarte karte : spielerHaende.get(indexSpieler)) {
- System.out.print("Index: " + j +"\t");
- System.out.println(karte);//Karte wird ausgegeben
- j++;//zahl wird erhöht für die nächste Karte
- }
- System.out.println();
+ public void zeigeHaende(int indexSpieler) {
+ int j = 1;
+ for (UnoKarte karte : spielerHaende.get(indexSpieler)) {
+ System.out.print("Index: " + j +"\t");
+ j++;
+ }
//Diese Methode zeigt die Hand des Spielers
}
- public void befuelleSpieleHand(int spielerIndex, UnoDeck deck, int anzahl){//2
- Random rand = new Random(); // random zahl wird in rand gespeichert
+ public void befuelleSpieleHand(int spielerIndex, UnoDeck deck, int anzahl){
+ Random rand = new Random();
for (int i = 0; i < anzahl; i++) {
- int n = rand.nextInt(deck.hand.size()); // random zahl von 0 bis DeckSize
- fuegeKarteHinzu(spielerIndex, deck, n); // methode wird aufgerufen
+ int n = rand.nextInt(deck.hand.size());
+ fuegeKarteHinzu(spielerIndex, deck, n);
}
//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++){
- 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
}
}
}
-
diff --git a/src/UNO.java b/src/UNO.java
index 74ed1011028ea15271773fe4e23848b729e3042e..d3538e47bc82f43184056f48e51ac896f30cd904 100644
--- a/src/UNO.java
+++ b/src/UNO.java
@@ -1,153 +1,7 @@
-import java.util.Scanner;
-
public class UNO {
public static void main(String[] args) {
- //Die benötigten Klassen werden aufgerufen
- UnoDeck deck = new UnoDeck();
- 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;
- }
- }
- }
- }
+ RunGame rungame = new RunGame();
+ rungame.Start();
}
}
-
diff --git a/src/UnoDeck.java b/src/UnoDeck.java
index 2e59f87a6b50df4bb03355a4bb61a89c047c6cb3..303fb4dcd0f5eaab6f96fc4f983b6fc2836c3564 100644
--- a/src/UnoDeck.java
+++ b/src/UnoDeck.java
@@ -24,7 +24,6 @@ public class UnoDeck {
public void zeigeDeck() {
for (UnoKarte karte : hand) {
- System.out.println(karte);
//Diese Methode gibt das Array der UnoHand aus
}
}
@@ -79,7 +78,6 @@ public class UnoDeck {
fuegeKarteHinzu(new UnoKarte(Farbe.Wild, Wert.Multicolor));
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
}
}
-
diff --git a/src/UnoKarte.java b/src/UnoKarte.java
index bcee8a4fd6347c592843e3a6aa50c27e66f7f833..089c0c254934e698ca39413b39c40c717e3e3daa 100644
--- a/src/UnoKarte.java
+++ b/src/UnoKarte.java
@@ -29,4 +29,4 @@ enum Farbe {
enum Wert {
Null, Eins, Zwei, Drei, Vier, Fuenf, Sechs, Sieben, Acht, Neun, Aussetzen, Richtungswechsel, Zwei_Ziehen, Multicolor, Draw_Four
//Das sind die eigenschaften der jeweiligen Karten
-}
+}
\ No newline at end of file
diff --git a/src/UnoSpielfeld.java b/src/UnoSpielfeld.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d2e62b5123f691553714a9230a0402f066846c6
--- /dev/null
+++ b/src/UnoSpielfeld.java
@@ -0,0 +1,354 @@
+
+
+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; }
+}
diff --git a/src/farbAuswahl.java b/src/farbAuswahl.java
new file mode 100644
index 0000000000000000000000000000000000000000..180e995b566e0dafcbc9cf2925435825f6cc00c6
--- /dev/null
+++ b/src/farbAuswahl.java
@@ -0,0 +1,200 @@
+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;
+ }
+}