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;
+    }
+}