diff --git a/src/BotInterface.java b/src/BotInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e42269c17e163151390097f8575d634072c5afb
--- /dev/null
+++ b/src/BotInterface.java
@@ -0,0 +1,82 @@
+
+
+//Daran hat Justin Klein gearbeitet
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.ArrayList;
+public class BotInterface extends JFrame{
+ private JPanel kartenPanel1;
+ private JPanel kartenPanel2;
+ private JLabel BotLabel;
+ public BotInterface(){
+ setTitle("Bot Ãœberblick");
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLayout(new BorderLayout());
+
+ kartenPanel1 = new JPanel();
+ JScrollPane kartenScrollPanel1;
+ kartenPanel1.setLayout(new FlowLayout(FlowLayout.LEFT));
+ kartenScrollPanel1 = new JScrollPane(kartenPanel1);
+ add(kartenScrollPanel1, BorderLayout.NORTH);
+
+ kartenPanel2 = new JPanel();
+ JScrollPane kartenScrollPanel2;
+ kartenPanel2.setLayout(new FlowLayout(FlowLayout.LEFT));
+ kartenScrollPanel2 = new JScrollPane(kartenPanel2);
+ add(kartenScrollPanel2, BorderLayout.CENTER);
+
+ BotLabel = new JLabel();
+ add(BotLabel,BorderLayout.SOUTH);
+
+ setSize(800,700);
+ setVisible(true);
+ revalidate();
+ repaint();
+ }
+ public void anzeige(ArrayList<UnoKarte> LegbareKarten,SpielerHand spielerHand, int aktuellerSpieler,String Bot){
+
+ aktuelleKarteHinzufuegen(spielerHand,aktuellerSpieler);
+
+ legbareKarteHinzufuegen(LegbareKarten);
+
+ BotLabel.setText(Bot);
+ BotLabel.setFont(new Font("Arial", Font.PLAIN, 20));
+ }
+
+ public void aktuelleKarteHinzufuegen( SpielerHand spielerHand, int aktuellerSpieler){
+ int size = spielerHand.spielerHaende.get(aktuellerSpieler).size()-1;
+ kartenPanel1.removeAll();
+ revalidate();
+ repaint();
+ for (int i = 0; i <= size; i++) {
+ JButton kartenButton = createImageButton("UnoKarten/"+Bild(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))+".png"); // Passe den Pfad zum Kartenbild an
+ kartenPanel1.add(kartenButton);
+ }
+ }
+ public void legbareKarteHinzufuegen(ArrayList<UnoKarte> LegbareKarten){
+ int size = LegbareKarten.size()-1;
+ kartenPanel2.removeAll();
+ revalidate();
+ repaint();
+ for (int i = 0; i <= size; i++) {
+ JButton kartenButton = createImageButton("UnoKarten/"+Bild(LegbareKarten.get(i))+".png"); // Passe den Pfad zum Kartenbild an
+ kartenPanel2.add(kartenButton);
+ }
+ }
+ 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 String Bild(UnoKarte aktuelleKarte){
+ Farbe farbe = aktuelleKarte.getFarbe();
+ Wert wert = aktuelleKarte.getWert();
+ String wort = farbe + "_" + wert;
+ return wort;
+
+ }
+}
diff --git a/src/BotKontroll.java b/src/BotKontroll.java
new file mode 100644
index 0000000000000000000000000000000000000000..842e16ab4e60288117f20cfa5c3ce6e012fcb8e7
--- /dev/null
+++ b/src/BotKontroll.java
@@ -0,0 +1,41 @@
+
+//Diese Klasse soll denn Bots ihre jeweilige Boteigenschaft geben und sie speichern
+
+//Daran hat Justin Klein gearbeitet
+import java.util.ArrayList;
+import java.util.Random;
+public class BotKontroll {
+
+ private ArrayList<Integer> isBot;
+ public int BotKontroll(SpielerHand spielerHand,int aktuellerSpieler, UnoKarte aktuelleKarte, Regelwerk regel,UnoDeck deck, UnoSpielfeld spielfeld,BotInterface anzeige, boolean Interface) {
+ Random rand = new Random();
+
+ if (isBot.get(aktuellerSpieler) == null) {
+ int randome = rand.nextInt(1,2);
+ isBot.set(aktuellerSpieler, randome);
+ }
+
+ int kartenIndex = -1;
+ switch (isBot.get(aktuellerSpieler)){
+ case 1 -> {
+ Bot_1 bot_1 = new Bot_1();
+ kartenIndex = bot_1.Bot_1(spielerHand, aktuellerSpieler, aktuelleKarte, regel, deck, spielfeld, anzeige, Interface);
+ }case 2 -> {
+ Bot_2 bot_2 = new Bot_2();
+ kartenIndex = bot_2.Bot_2(spielerHand, aktuellerSpieler, aktuelleKarte, regel, deck, spielfeld, anzeige, Interface);
+ }case 3 ->{
+ Bot_3 bot_3 = new Bot_3();
+ kartenIndex = bot_3.Bot_3(spielerHand, aktuellerSpieler, aktuelleKarte, regel, deck, spielfeld, anzeige, Interface);
+ }
+ }
+ return kartenIndex;
+ }
+
+ public void setBotKontroll(int lenght){
+ isBot = new ArrayList<>();
+
+ for(int i = 0; i < lenght; i++){
+ isBot.add(null);
+ }
+ }
+}
diff --git a/src/Bot_1.java b/src/Bot_1.java
new file mode 100644
index 0000000000000000000000000000000000000000..aef55413bc362abca9761038f91d55b91df11b41
--- /dev/null
+++ b/src/Bot_1.java
@@ -0,0 +1,209 @@
+
+/*
+ Der Bot versucht über den Verlauf des Spiels seine Wild Karten aufzusparen, um sie dann am Ende legen zu können
+ */
+// An diesem Bot haben Alexandros Tzialidiss und Luan Blum gearbeitet
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+public class Bot_1 {
+
+ public boolean isWild;
+ public boolean neuKarte = false;
+
+ private ArrayList<UnoKarte> LegbareKarten;
+ public int Bot_1(SpielerHand spielerHand,int aktuellerSpieler, UnoKarte aktuelleKarte, Regelwerk regel,UnoDeck deck, UnoSpielfeld spielfeld,BotInterface anzeige, boolean Interface){
+ LegbareKarten = new ArrayList<UnoKarte>();
+ legbareKarten(spielerHand,aktuellerSpieler,aktuelleKarte,regel);
+ sortiereUnoKarten(LegbareKarten);
+ int lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ int size = LegbareKarten.size();
+ if(Interface == true) {
+ String Bot = "Bot 1";
+ anzeige.anzeige(LegbareKarten, spielerHand, aktuellerSpieler, Bot);
+ }
+ isWild = false;
+ if(size > 0) {
+ if (LegbareKarten.get(size - 1).getFarbe() == Farbe.Wild) {
+ isWild = true;
+ }
+ }
+ if(isWild == true && spielerHand.spielerHaende.get(aktuellerSpieler).size() > 1 && LegbareKarten.size() > 1){
+ aktuelleKarte = LegbareKarten.get(0);
+ neuKarte = true;
+ } else if (isWild == true && size > 2 && LegbareKarten.get(size-2).getFarbe() == Farbe.Wild ) {
+ aktuelleKarte = LegbareKarten.get(size-2);
+ neuKarte = true;
+ } else if(isWild == false && spielerHand.spielerHaende.get(aktuellerSpieler).size() == 1 ){
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ boolean geht = true;
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(geht == ueberpruefeKarte(aktuelleKarte,neueKarte,regel) && (neueKarte.getWert() != Wert.Draw_Four || neueKarte.getWert() != Wert.Multicolor)){
+ aktuelleKarte = neueKarte;
+ neuKarte = true;
+ }
+ } else if (isWild == false && spielerHand.spielerHaende.get(aktuellerSpieler).size() > 1 && LegbareKarten.size() >=1) {
+ aktuelleKarte = LegbareKarten.get(0);
+ neuKarte = true;
+ } else if(isWild == true && spielerHand.spielerHaende.get(aktuellerSpieler).size() <= 1){
+ aktuelleKarte = LegbareKarten.get(0);
+ neuKarte = true;
+ }else{
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ boolean geht = true;
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(geht == ueberpruefeKarte(aktuelleKarte,neueKarte,regel) && neueKarte.getFarbe() != Farbe.Wild){
+ aktuelleKarte = neueKarte;
+ neuKarte = true;
+ } else if(geht == ueberpruefeKarte(aktuelleKarte,neueKarte,regel) && isWild == false && neueKarte.getFarbe() == Farbe.Wild) {
+
+ }
+ }
+
+ int kartenIndex = -1;
+ if(neuKarte == true) {
+ if (regel.color.size() == 2) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(1) || aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ regel.color.remove(1);
+ }
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ }
+ int[] farben = {0,0,0,0,0};
+ if((aktuelleKarte.getWert() == Wert.Draw_Four || aktuelleKarte.getWert() == Wert.Multicolor) && neuKarte == true){
+ for(UnoKarte karte : spielerHand.spielerHaende.get(aktuellerSpieler)){
+ switch (karte.getFarbe()){
+ case Gruen ->
+ farben[0] +=1;
+ case Gelb ->
+ farben[1] +=1;
+ case Blau ->
+ farben[2] +=1;
+ case Rot ->
+ farben[3] +=1;
+ case Wild ->
+ farben[4] +=1;
+ }
+ }
+ int max = farben[0];
+ int id = 0;
+
+ for (int i = 1; i < farben.length; i++) {
+ if (farben[i] > max) {
+ max = farben[i];
+ id = i;
+ }
+ }
+ switch (id){
+ case 0 -> {
+ regel.color.add(Farbe.Gruen);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Multicolor);
+ }
+ }
+ case 1 -> {
+ regel.color.add(Farbe.Gelb);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Multicolor);
+ }
+ }
+ case 2 -> {
+ regel.color.add(Farbe.Blau);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Multicolor);
+ }
+ }
+ case 3 -> {
+ regel.color.add(Farbe.Rot);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Multicolor);
+ }
+ }
+ default -> {
+ }
+ }
+ }
+ return kartenIndex;
+ }
+
+ public void legbareKarten(SpielerHand spielerHand,int aktuellerSpieler,UnoKarte aktuelleKarte, Regelwerk regel){
+ int size = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ boolean geht = true;
+ for(int i = 0; i < size; i++){
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(i);
+ if(geht == ueberpruefeKarte(aktuelleKarte, neueKarte, regel)){
+ LegbareKarten.add(neueKarte);
+ }
+ }
+ }
+
+ public Boolean ueberpruefeKarte(UnoKarte aktuelleKarte, UnoKarte neueKarte, Regelwerk regel){
+ if(regel.color.size() == 2) {
+ if(regel.color.get(1) == neueKarte.getFarbe() || regel.color.get(0) == neueKarte.getFarbe()){
+ return true;
+ }else {
+ return false;
+ }
+ }else if (aktuelleKarte.getFarbe() == neueKarte.getFarbe()) {
+ return true;
+ } else if (aktuelleKarte.getWert() == neueKarte.getWert()) {
+ return true;
+ }else if(neueKarte.getFarbe() == Farbe.Wild || aktuelleKarte.getFarbe() == Farbe.Wild){
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public static void sortiereUnoKarten(ArrayList<UnoKarte> LegbareKarten){
+ Collections.sort(LegbareKarten, new Comparator<UnoKarte>() {
+ @Override
+ public int compare(UnoKarte karte1, UnoKarte karte2) {
+ int farbenIndex1 = getFarbenIndex(karte1.getFarbe());
+ int farbenIndex2 = getFarbenIndex(karte2.getFarbe());
+
+ return Integer.compare(farbenIndex1, farbenIndex2);
+ }
+ });
+ }
+
+ public static int getFarbenIndex(Farbe farbe) {
+ switch (farbe){
+ case Rot -> {
+ return 0;
+ }case Blau -> {
+ return 1;
+ }case Gelb -> {
+ return 2;
+ }case Gruen -> {
+ return 3;
+ }case Wild -> {
+ return 4;
+ }default -> {
+ return -1;
+ }
+ }
+ }
+}
diff --git a/src/Bot_2.java b/src/Bot_2.java
new file mode 100644
index 0000000000000000000000000000000000000000..451ed9a7f9ea7ddd099ec51e71cce5e9ed67ef44
--- /dev/null
+++ b/src/Bot_2.java
@@ -0,0 +1,243 @@
+
+/*
+ Der Bot bewertet Karten nach einem Punkte System. Je höher die Punkte um so nerviger ist die Karte
+ */
+
+// An diesem Bot haben Ismail Eren Cakan und Furkan Celik gearbeitet
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+public class Bot_2 {
+ private boolean neuKarte = false;
+
+ private ArrayList<UnoKarte> LegbareKarten;
+ public int Bot_2(SpielerHand spielerHand,int aktuellerSpieler, UnoKarte aktuelleKarte, Regelwerk regel,UnoDeck deck, UnoSpielfeld spielfeld,BotInterface anzeige,boolean Interface){
+ UnoKarte alteKarte = aktuelleKarte;
+ LegbareKarten = new ArrayList<UnoKarte>();
+ legbareKarten(spielerHand,aktuellerSpieler,aktuelleKarte,regel);
+ sortiereUnoKarten(LegbareKarten);
+ int lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ int size = LegbareKarten.size();
+
+ if(Interface == true) {
+ String Bot = "Bot 2";
+ anzeige.anzeige(LegbareKarten, spielerHand, aktuellerSpieler, Bot);
+ }
+ if(size >=1) {
+ UnoKarte besteKarte = LegbareKarten.get(0);
+ int besteBewertung = bewerteKarte(besteKarte, aktuelleKarte);
+
+ for (UnoKarte karte : LegbareKarten) {
+ int bewertung = bewerteKarte(karte, aktuelleKarte);
+ if (bewertung > besteBewertung) {
+ besteBewertung = bewertung;
+ besteKarte = karte;
+ }
+ }
+ aktuelleKarte = besteKarte;
+ neuKarte = true;
+ } else if (size == 0) {
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(true == ueberpruefeKarte(aktuelleKarte,neueKarte,regel)){
+ aktuelleKarte = neueKarte;
+ neuKarte = true;
+ }
+ }else {
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(true == ueberpruefeKarte(aktuelleKarte,neueKarte,regel)){
+ aktuelleKarte = neueKarte;
+ neuKarte = true;
+ }
+ }
+
+ int kartenIndex = -1;
+ if(neuKarte == true) {
+ if (regel.color.size() == 2) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(1) || aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ regel.color.remove(1);
+ }
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ }
+
+ int[] farben = {0,0,0,0,0};
+ if((aktuelleKarte.getWert() == Wert.Draw_Four || aktuelleKarte.getWert() == Wert.Multicolor) && neuKarte == true){
+ for(UnoKarte karte : spielerHand.spielerHaende.get(aktuellerSpieler)){
+ switch (karte.getFarbe()){
+ case Gruen ->
+ farben[0] +=1;
+ case Gelb ->
+ farben[1] +=1;
+ case Blau ->
+ farben[2] +=1;
+ case Rot ->
+ farben[3] +=1;
+ case Wild ->
+ farben[4] +=1;
+ }
+ }
+ int max = farben[0];
+ int id = 0;
+
+ for (int i = 1; i < farben.length; i++) {
+ if (farben[i] > max) {
+ max = farben[i];
+ id = i;
+ }
+ }
+ switch (id){
+ case 0 -> {
+ if(alteKarte.getFarbe() == Farbe.Gruen){
+
+ }else {
+ regel.color.add(Farbe.Gruen);
+ }
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Multicolor);
+ }
+ }
+ case 1 -> {
+ if(alteKarte.getFarbe() == Farbe.Gelb){
+
+ }else {
+ regel.color.add(Farbe.Gelb);
+ }
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Multicolor);
+ }
+ }
+ case 2 -> {
+ if(alteKarte.getFarbe() == Farbe.Blau){
+
+ }else {
+ regel.color.add(Farbe.Blau);
+ }
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Multicolor);
+ }
+ }
+ case 3 -> {
+ if(alteKarte.getFarbe() == Farbe.Rot){
+
+ }else {
+ regel.color.add(Farbe.Rot);
+ }
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Multicolor);
+ }
+ }
+ default -> {
+ }
+ }
+ }
+
+ return kartenIndex;
+ }
+
+ public void legbareKarten(SpielerHand spielerHand,int aktuellerSpieler,UnoKarte aktuelleKarte, Regelwerk regel){
+ int size = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ boolean geht = true;
+ for(int i = 0; i < size; i++){
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(i);
+ if(geht == ueberpruefeKarte(aktuelleKarte, neueKarte, regel)){
+ LegbareKarten.add(neueKarte);
+ }
+ }
+ }
+
+ public Boolean ueberpruefeKarte(UnoKarte aktuelleKarte, UnoKarte neueKarte, Regelwerk regel){
+ if(regel.color.size() == 2) {
+ if(regel.color.get(1) == neueKarte.getFarbe() || regel.color.get(0) == neueKarte.getFarbe()){
+ return true;
+ }else {
+ return false;
+ }
+ }else if (aktuelleKarte.getFarbe() == neueKarte.getFarbe()) {
+ return true;
+ } else if (aktuelleKarte.getWert() == neueKarte.getWert()) {
+ return true;
+ }else if(neueKarte.getFarbe() == Farbe.Wild || aktuelleKarte.getFarbe() == Farbe.Wild){
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public static void sortiereUnoKarten(ArrayList<UnoKarte> LegbareKarten){
+ Collections.sort(LegbareKarten, new Comparator<UnoKarte>() {
+ @Override
+ public int compare(UnoKarte karte1, UnoKarte karte2) {
+ int farbenIndex1 = getFarbenIndex(karte1.getFarbe());
+ int farbenIndex2 = getFarbenIndex(karte2.getFarbe());
+
+ return Integer.compare(farbenIndex1, farbenIndex2);
+ }
+ });
+ }
+
+ public static int getFarbenIndex(Farbe farbe) {
+ switch (farbe){
+ case Rot -> {
+ return 0;
+ }case Blau -> {
+ return 1;
+ }case Gelb -> {
+ return 2;
+ }case Gruen -> {
+ return 3;
+ }case Wild -> {
+ return 4;
+ }default -> {
+ return -1;
+ }
+ }
+ }
+
+ public static int bewerteKarte(UnoKarte besteKarte, UnoKarte aktuelleKarte){
+ int bewertung = 0;
+
+ if(besteKarte.getWert() == Wert.Zwei_Ziehen){
+ bewertung +=20;
+ }else if(besteKarte.getWert() == Wert.Draw_Four){
+ bewertung += 50;
+ }else if(besteKarte.getWert() == Wert.Aussetzen || besteKarte.getWert() == Wert.Richtungswechsel){
+ bewertung += 10;
+ }
+
+ if(besteKarte.getFarbe() == Farbe.Wild){
+ bewertung += 3;
+ }
+
+ if(besteKarte.getFarbe() != aktuelleKarte.getFarbe()) {
+ bewertung += 5;
+ }else if(besteKarte.getWert() != aktuelleKarte.getWert()){
+ bewertung += 2;
+ }
+ return bewertung;
+ }
+}
diff --git a/src/Bot_3.java b/src/Bot_3.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a4eca0ba7dfefb61baf371316c2c2f117dd1414
--- /dev/null
+++ b/src/Bot_3.java
@@ -0,0 +1,302 @@
+
+/*
+ der Bot versucht durch legen von +2 und +4 Karten den Spieler daran zu hindern das spiel zu gewinnen
+ */
+// An diesem Bot hat Justin Klein gearbeitet
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+public class Bot_3 {
+
+ boolean isZwei = false;
+ boolean isVier = false;
+ boolean isMulticolor = false;
+ boolean neuKarte = false;
+ Farbe zwingendeFarbe;
+
+ private ArrayList<UnoKarte> LegbareKarten;
+ public int Bot_3(SpielerHand spielerHand,int aktuellerSpieler, UnoKarte aktuelleKarte, Regelwerk regel,UnoDeck deck, UnoSpielfeld spielfeld,BotInterface anzeige,boolean Interface){
+ LegbareKarten = new ArrayList<UnoKarte>();
+ legbareKarten(spielerHand,aktuellerSpieler,aktuelleKarte,regel);
+ sortiereUnoKarten(LegbareKarten);
+ int lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ int size = LegbareKarten.size();
+ if(Interface == true) {
+ String Bot = "Bot 3";
+ anzeige.anzeige(LegbareKarten, spielerHand, aktuellerSpieler,Bot);
+ }
+ int anzahlspielerKarten = spielerHand.spielerHaende.get(regel.reihenfolge.get(0)).size();
+
+ for(UnoKarte karte : spielerHand.spielerHaende.get(aktuellerSpieler)){
+ if(karte.getWert() == Wert.Draw_Four){
+ isVier = true;
+ } else if (karte.getWert() == Wert.Zwei_Ziehen) {
+ isZwei = true;
+ }
+ }
+ int anzahl = 0;
+ for(UnoKarte karten : spielerHand.spielerHaende.get(aktuellerSpieler)){
+ if (isZwei == true || isVier == true){
+ if (karten.getWert() == Wert.Zwei_Ziehen || karten.getWert() == Wert.Draw_Four){
+ anzahl += 1;
+ }
+ }
+ }
+ if(anzahl == lenght){
+ boolean passt = false;
+ if(LegbareKarten.size() >= 1) {
+ for (UnoKarte karten : LegbareKarten){
+ if(ueberpruefeKarte(aktuelleKarte,karten,regel) == true){
+ aktuelleKarte = karten;
+ neuKarte = true;
+ passt = true;
+ break;
+ }
+ }
+ }
+ if(passt == false){
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(ueberpruefeKarte(aktuelleKarte,neueKarte,regel)){
+ aktuelleKarte = neueKarte;
+ neuKarte = true;
+ }
+ }
+ }else if(anzahlspielerKarten > 2){
+ if(isZwei == true || isVier == true) {
+ boolean passend = false;
+ if(LegbareKarten.size() >= 1) {
+ for (UnoKarte karte : LegbareKarten) {
+ if (karte.getWert() != Wert.Draw_Four && karte.getWert() != Wert.Zwei_Ziehen) {
+ if(ueberpruefeKarte(aktuelleKarte,karte,regel)){
+ aktuelleKarte = karte;
+ neuKarte = true;
+ passend = true;
+ }
+ }
+ }
+ }
+ if(passend == false){
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ if(spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1).getWert() != Wert.Draw_Four && spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1).getWert() != Wert.Zwei_Ziehen) {
+ if (ueberpruefeKarte(aktuelleKarte, spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght - 1), regel) == true) {
+ aktuelleKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght - 1);
+ neuKarte = true;
+ }
+ }
+ }
+ }else{
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ if(spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1).getWert() != Wert.Draw_Four && spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1).getWert() != Wert.Zwei_Ziehen) {
+ if (ueberpruefeKarte(aktuelleKarte, spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght - 1), regel) == true) {
+ aktuelleKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght - 1);
+ neuKarte = true;
+ }
+ }
+ }
+ }else if(anzahlspielerKarten <= 2) {
+ if(isZwei == true){
+ int menge = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ for(int j = 0; j < menge; j++) {
+ UnoKarte karte = spielerHand.spielerHaende.get(aktuellerSpieler).get(j);
+ if(karte.getWert() == Wert.Zwei_Ziehen) {
+ if (ueberpruefeKarte(aktuelleKarte, karte, regel) == true) {
+ aktuelleKarte = karte;
+ neuKarte = true;
+ break;
+ }else {
+ for (int i = 0; i < menge; i++){
+ UnoKarte karte2 = spielerHand.spielerHaende.get(aktuellerSpieler).get(i);
+ if(karte2.getFarbe() == karte.getFarbe() && aktuelleKarte.getWert() == karte2.getWert()){
+ aktuelleKarte = karte2;
+ neuKarte = true;
+ break;
+ } else if (karte2.getFarbe() == Farbe.Wild && karte2.getWert() == Wert.Multicolor) {
+ aktuelleKarte = karte2;
+ neuKarte = true;
+ isMulticolor = true;
+ zwingendeFarbe = karte.getFarbe();
+ break;
+ }else{
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ UnoKarte neuekarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(ueberpruefeKarte(aktuelleKarte,neuekarte,regel)){
+ aktuelleKarte = neuekarte;
+ neuKarte = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }else if(isVier == true){
+ for(UnoKarte karte : spielerHand.spielerHaende.get(aktuellerSpieler)){
+ if(karte.getWert() == Wert.Draw_Four){
+ aktuelleKarte = karte;
+ neuKarte = true;
+ break;
+ }
+ }
+ }else{
+ spielerHand.befuelleSpieleHand(aktuellerSpieler,deck,1);
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ UnoKarte neuekarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(lenght-1);
+ if(ueberpruefeKarte(aktuelleKarte,neuekarte,regel)){
+ aktuelleKarte = neuekarte;
+ neuKarte = true;
+ }
+ }
+ }
+ int kartenIndex = -1;
+ if(neuKarte == true) {
+ if (regel.color.size() == 2) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(1) || aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ if (aktuelleKarte.getFarbe() == regel.color.get(0)) {
+ regel.color.remove(1);
+ }
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ } else {
+ lenght = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ for (int i = 0; i < lenght; i++) {
+ if (aktuelleKarte.equals(spielerHand.spielerHaende.get(aktuellerSpieler).get(i))) {
+ kartenIndex = i;
+ }
+ }
+ }
+ }
+ if(isMulticolor == true){
+ regel.color.add(zwingendeFarbe);
+ spielfeld.wechsleWunschKarte(zwingendeFarbe,Wert.Multicolor);
+ }else if (neuKarte == true) {
+ int[] farben = {0, 0, 0, 0, 0};
+ if (aktuelleKarte.getWert() == Wert.Draw_Four || aktuelleKarte.getWert() == Wert.Multicolor) {
+ for (UnoKarte karte : spielerHand.spielerHaende.get(aktuellerSpieler)) {
+ switch (karte.getFarbe()) {
+ case Gruen -> farben[0] += 1;
+ case Gelb -> farben[1] += 1;
+ case Blau -> farben[2] += 1;
+ case Rot -> farben[3] += 1;
+ case Wild -> farben[4] += 1;
+ }
+ }
+ int max = farben[0];
+ int id = 0;
+
+ for (int i = 1; i < farben.length; i++) {
+ if (farben[i] > max) {
+ max = farben[i];
+ id = i;
+ }
+ }
+ switch (id) {
+ case 0 -> {
+ regel.color.add(Farbe.Gruen);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gruen, Wert.Multicolor);
+ }
+ }
+ case 1 -> {
+ regel.color.add(Farbe.Gelb);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Gelb, Wert.Multicolor);
+ }
+ }
+ case 2 -> {
+ regel.color.add(Farbe.Blau);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Blau, Wert.Multicolor);
+ }
+ }
+ case 3 -> {
+ regel.color.add(Farbe.Rot);
+ if (Wert.Draw_Four == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Draw_Four);
+ } else if (Wert.Multicolor == aktuelleKarte.getWert()) {
+ spielfeld.wechsleWunschKarte(Farbe.Rot, Wert.Multicolor);
+ }
+ }
+ default -> {
+ }
+ }
+ }
+ }
+ return kartenIndex;
+ }
+
+ public void legbareKarten(SpielerHand spielerHand,int aktuellerSpieler,UnoKarte aktuelleKarte, Regelwerk regel){
+ int size = spielerHand.spielerHaende.get(aktuellerSpieler).size();
+ boolean geht = true;
+ for(int i = 0; i < size; i++){
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(aktuellerSpieler).get(i);
+ if(geht == ueberpruefeKarte(aktuelleKarte, neueKarte, regel)){
+ LegbareKarten.add(neueKarte);
+ }
+ }
+ }
+
+ public Boolean ueberpruefeKarte(UnoKarte aktuelleKarte, UnoKarte neueKarte, Regelwerk regel){
+ if(regel.color.size() == 2) {
+ if(regel.color.get(1) == neueKarte.getFarbe() || regel.color.get(0) == neueKarte.getFarbe()){
+ return true;
+ }else {
+ return false;
+ }
+ }else if (aktuelleKarte.getFarbe() == neueKarte.getFarbe()) {
+ return true;
+ } else if (aktuelleKarte.getWert() == neueKarte.getWert()) {
+ return true;
+ }else if(neueKarte.getFarbe() == Farbe.Wild || aktuelleKarte.getFarbe() == Farbe.Wild){
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public static void sortiereUnoKarten(ArrayList<UnoKarte> LegbareKarten){
+ Collections.sort(LegbareKarten, new Comparator<UnoKarte>() {
+ @Override
+ public int compare(UnoKarte karte1, UnoKarte karte2) {
+ int farbenIndex1 = getFarbenIndex(karte1.getFarbe());
+ int farbenIndex2 = getFarbenIndex(karte2.getFarbe());
+
+ return Integer.compare(farbenIndex1, farbenIndex2);
+ }
+ });
+ }
+
+ public static int getFarbenIndex(Farbe farbe) {
+ switch (farbe){
+ case Rot -> {
+ return 0;
+ }case Blau -> {
+ return 1;
+ }case Gelb -> {
+ return 2;
+ }case Gruen -> {
+ return 3;
+ }case Wild -> {
+ return 4;
+ }default -> {
+ return -1;
+ }
+ }
+ }
+}
diff --git a/src/RunGame.java b/src/RunGame.java
index d9e94a77abda713d07a0bb0b3101c588b2bbb731..8b4a418a2b81596f6da2374f774c095dab87e25c 100644
--- a/src/RunGame.java
+++ b/src/RunGame.java
@@ -2,7 +2,12 @@
An dieser Datei hat Luan Blum größtenteils gearbeitet
*/
+import java.util.ArrayList;
+
public class RunGame {
+
+ public boolean Interface = true;
+
UnoDeck deck = new UnoDeck();
Regelwerk regel = new Regelwerk();
farbAuswahl farbAuswahl = new farbAuswahl();
@@ -10,6 +15,8 @@ public class RunGame {
final Object lock = new Object();
final Object locked = new Object();
private int lenght = 0;
+ public ArrayList<Boolean> isBot;
+ public BotInterface anzeige;
public void Start() {
@@ -28,6 +35,9 @@ public class RunGame {
lenght = Names.getgroesse();
+ isBot = new ArrayList<Boolean>();
+ isBot = Names.getisBot();
+
if (lenght > 4) {
deck.befuellen();
deck.befuellen();
@@ -63,9 +73,18 @@ public class RunGame {
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);
+ UnoSpielfeld spielFeld = new UnoSpielfeld(aktuelleKarte, spielerHand, regel,lock,lenght,isBot);
+
+
+ if(Interface == true){
+ anzeige = new BotInterface();
+ }
+
+ BotKontroll botKontroll = new BotKontroll();
+ botKontroll.setBotKontroll(spielerHand.spielerHaende.size());
while (!win) {
+ spielFeld.aktuelleKarte(aktuelleKarte);
reihen = regel.reihenfolge();
spielFeld.colorPlayer(reihen);
boolean start = false;
@@ -81,200 +100,225 @@ public class RunGame {
}
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(isBot.get(reihen) == false){
+ 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);
+ }
- 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;
+ 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;
- //Hier wird die Karte dann geprüft ob es möglich ist diese zu legen
+ //Entscheidet der Spieler sich für das legen der Karte wird wird die zu legende Karte entnommen
- } else {
+ 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;
- //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();
+ //Hier wird die Karte dann geprüft ob es möglich ist diese zu legen
- //Diese Schleife prüft erneut ob der Spieler eine Karte Legen oder ziehen möchte
+ } else {
- }
- 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
+ //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();
- 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;
+ //Diese Schleife prüft erneut ob der Spieler eine Karte Legen oder ziehen möchte
- //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));
+ 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;
- // Entscheidet der Spieler sich für das zihen der Karte wird ihm eine Karte hinzugefügt
+ //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));
- synchronized (lock) {
- try {
- lock.wait();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
+ // Entscheidet der Spieler sich für das zihen der Karte wird ihm eine Karte hinzugefügt
- while (geht == true) {
- kartelegen = false;
- karteziehen = false;
- spielFeld.highLegen();
- spielFeld.highBehalten();
- while ((kartelegen || karteziehen) != true) {
+ synchronized (lock) {
try {
- Thread.sleep(100);
+ lock.wait();
} catch (InterruptedException e) {
- throw new RuntimeException(e);
+ e.printStackTrace();
}
- 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);
+ 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
+ //Hier findet die Prüfung ob die Karte legbar ist statt
+ }
+ geht = false;
}
- 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) {
+ } 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 {
- Thread.sleep(100);
+ lock.wait();
} catch (InterruptedException e) {
- throw new RuntimeException(e);
+ e.printStackTrace();
}
- 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
+ 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
- } 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.highBehaltenundo();
+ spielFeld.highLegenundo();
+ if (karteziehen == true) {
spielFeld.changeKarteziehenundo();
+ geht = false;
- //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
+ //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;
}
- geht = false;
}
}
- }
- if(spielerHand.spielerHaende.get(spielFeld.getSpielerIndex()).size() == 1){
+ 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
+ //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;
+ 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();
+ }else if (isBot.get(reihen) == true){
+ int kartenIndex = botKontroll.BotKontroll(spielerHand,reihen,aktuelleKarte,regel,deck, spielFeld,anzeige,Interface);
+ if(kartenIndex != -1){
+ UnoKarte neueKarte = spielerHand.spielerHaende.get(reihen).get(kartenIndex);
+ if(regel.karteLegbar(aktuelleKarte,neueKarte,deck,spielerHand,lenght) == true){
+ aktuelleKarte = neueKarte;
+ spielerHand.entferneKarteHand(reihen,kartenIndex + 1,deck,zug);
+ spielFeld.aktuelleKarte(aktuelleKarte);
+ }
+ }
+ if(spielerHand.spielerHaende.get(regel.reihenfolge.get(1)).size() == 0) {
+ spielFeld.beenden();
+ win = true;
+ Ende.EndScreen(spielerHand, regel.reihenfolge.get(1));
+ }
+ spielFeld.changeKarteziehenundo();
+ spielFeld.aktuelleKarte(aktuelleKarte);
+ spielFeld.Kartenausschalten();
try {
- Thread.sleep(2500);
+ Thread.sleep(200);
} 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/UnoSpielfeld.java b/src/UnoSpielfeld.java
index 236595b8ea5dc884711d393bbf944b8bef064614..8aa260721884368c6c09d94ed3603524c6839584 100644
--- a/src/UnoSpielfeld.java
+++ b/src/UnoSpielfeld.java
@@ -35,12 +35,15 @@ public class UnoSpielfeld extends JFrame {
public Farbe farbe;
Object lock = null;
private ArrayList<JButton> spielerButton;
+ private ArrayList<Boolean> isBot;
- public UnoSpielfeld(UnoKarte aktuelleKarte, SpielerHand spilerhand, Regelwerk regel,Object lock1,int lenght) {
+ public UnoSpielfeld(UnoKarte aktuelleKarte, SpielerHand spilerhand, Regelwerk regel,Object lock1,int lenght,ArrayList<Boolean> ifBot) {
this.lock = lock1;
spielerButton = new ArrayList<JButton>();
+ isBot = new ArrayList<Boolean>();
+ isBot = ifBot;
size = lenght;
// Fenstereinstellungen
@@ -108,7 +111,12 @@ public class UnoSpielfeld extends JFrame {
for(int j = 0; j < size ; j++){
int w = j;
int finalJ = j;
- JButton spielerLabel = new JButton("Spieler " + (w + 1) + ": \t " + spielerHand.spielerNamen[j]);
+ JButton spielerLabel = null;
+ if(isBot.get(w) == false){
+ spielerLabel = new JButton("Spieler " + (w + 1) + ": \t " + spielerHand.spielerNamen[j]);
+ }else if (isBot.get(w) == true){
+ spielerLabel = new JButton("Bot " + (w + 1) + ": \t " + spielerHand.spielerNamen[j]);
+ }
spielerPanel.add(spielerLabel);
spielerButton.add(spielerLabel);
spielerLabel.setFont(new Font("Arial", Font.PLAIN, 20));
@@ -230,8 +238,6 @@ public class UnoSpielfeld extends JFrame {
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();