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

Merge branch 'Bots' into 'master'

Update 15 files

See merge request !4
parents 9849161e cda65eb5
No related branches found
No related tags found
1 merge request!4Update 15 files
//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;
}
}
//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);
}
}
}
/*
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;
}
}
}
}
/*
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;
}
}
/*
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;
}
}
}
}
......@@ -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();
}
}
}
......@@ -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();
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment