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