Methoden Simon Says für LED Board

[BD85]

Hallo zusammen,

ich bin gerade dabei das Spiel Simon Says für ein 12x12 LED Board zu realisieren und stehe vor dem Problem, dass nach erfolgter Farbauswahl durch den Computer nicht auf die Eingabe des Spielers gewartet wird, sondern das Programm munter weiterläuft. Gibt es da von Haus aus eine Methode, mit der ich die Farbauswahl durch den Computer bis zur erfolgten Farbauswahl durch den Spieler unterbrechen kann?

Auch stelle ich mir die Frage, wie ich dann nach korrekter Farbauswahl das Programm dazu bringen kann, die Farbreihenfolge+1 nochmal abzufragen usw.

Ich wäre euch sehr dankbar, wenn ihr mir diesbezüglich weiterhelfen könntet.

Die beigefügte LEDControl lässt sich bei dem Projekt über Properties External Jars integrieren, sodass man das Programm auf einem simulierten LED Board ausprobieren kann.

 

[BD85]

Ich bin jetzt soweit, dass nach der Generierung der Random Zahl auf die Eingabe des Spielers gewartet wird. Jedoch wird immer nur die Eingabe der zuletzt generierten Zufallszahl erwartet, anstatt das gesamte Array nochmal abzufragen. Wie kann man das umgehen? Hilfe 😕

import ledControl.BoardController;
import java.awt.event.KeyEvent;
import ledControl.gui.KeyBuffer;
import java.util.ArrayList;
import java.util.Random;

public class NewLEDProjekt {

   private static BoardController controller;

   private static KeyBuffer buffer;

   public NewLEDProjekt() {
   }

   public static void main(String[] args) {
     // Den Boardcontroller anfordern
     controller = BoardController.getBoardController();

     // Den KeyBuffer anfordern
     buffer = controller.getKeyBuffer();

     // Standard LED Board Farben werden gesetzt
     setColorLinks(new int[]{0, 0, 80});   
     setColorOben(new int[]{80, 0, 0});
     setColorRechts(new int[]{0, 80, 0});
     setColorUnten(new int[]{80, 80, 0});
     setRandColor(new int[]{40, 40, 40});
     setDiagonalColor(new int[]{40, 40, 40});

     // Feld, welches der Spieler drückt
     int SpielerWahl;

     // Feld, welches der Computer drückt
     int ComputerWahl;

     // Zufallsgenerierte Zahl
     Random Zufallszahl = new Random();

     // Speicher für die vom Computer gedrückten Felder
     ArrayList<Integer> Computer = new ArrayList<Integer>();

     // Speicher für die vom Spieler gedrückten Felder
     ArrayList<Integer> Spieler = new ArrayList<Integer>();

     // Aufleuchten der vom Computer gewählten Farben

     do {
       ComputerWahl = Zufallszahl.nextInt(4);

       for (int i = 0; i < Computer.size(); i++) {
         if (Computer.get(i) == 0) {
           setColorOben(new int[]{127, 0, 0});
           controller.sleep(1000);
           setColorOben(new int[]{80, 0, 0});
           controller.updateLedStripe();
         } else if (Computer.get(i) == 1) {
           setColorRechts(new int[]{0, 127, 0});
           controller.sleep(1000);
           setColorRechts(new int[]{0, 80, 0});
           controller.updateLedStripe();
         } else if (Computer.get(i) == 2) {
           setColorUnten(new int[]{127, 127, 0});
           controller.sleep(1000);
           setColorUnten(new int[]{80, 80, 0});
           controller.updateLedStripe();
         }else if (Computer.get(i) == 3) {
           setColorLinks(new int[]{0, 0, 127});
           controller.sleep(1000);
           setColorLinks(new int[]{0, 0, 80});
           controller.updateLedStripe();
         }
       }
       Computer.add(ComputerWahl);

       if (ComputerWahl == 0) {
         setColorOben(new int[]{127, 0, 0});
         controller.sleep(1000);
         setColorOben(new int[]{80, 0, 0});
         controller.updateLedStripe();
       } else if (ComputerWahl == 1) {
         setColorRechts(new int[]{0, 127, 0});
         controller.sleep(1000);   
         setColorRechts(new int[]{0, 80, 0});
         controller.updateLedStripe();
       } else if (ComputerWahl == 2) {
         setColorUnten(new int[]{127, 127, 0});
         controller.sleep(1000);
         setColorUnten(new int[]{80, 80, 0});
         controller.updateLedStripe();
       }else if (ComputerWahl == 3) {
         setColorLinks(new int[]{0, 0, 127});
         controller.sleep(1000);
         setColorLinks(new int[]{0, 0, 80});
         controller.updateLedStripe();
       }

       // Spielereingaben
       // Endlosschleife   

       while(Spieler.size() < Computer.size()) {
         // Das letzte KeyEvent wird aus dem Buffer gelesen.
         KeyEvent event = buffer.pop();

         // Es wird geprueft, ob ueberhaupt eine Tastatureingabe vorliegt.
         if (event != null) {
           // Wenn eine Eingabe vorliegt, wird geprueft, ob es sich um ein
           // KEY_PRESSED-Event handelt, da dieses Programm nur auf das
           // druecken, nicht auf das loslassen einer Taste reagieren soll.
           if (event.getID() == java.awt.event.KeyEvent.KEY_PRESSED) {
             // Wenn ein KEY_PRESSED-Event vorliegt, wird geprueft, ob es sich
             // um eine der vier Pfeiltasten handelt.
             switch (event.getKeyCode()) {
               case java.awt.event.KeyEvent.VK_UP:
                 SpielerWahl = 0;
                 setColorOben(new int[]{127, 0, 0});
                 controller.sleep(1000);
                 setColorOben(new int[]{80, 0, 0});
                 controller.updateLedStripe();
                 Spieler.add(SpielerWahl);
                 break;
               case java.awt.event.KeyEvent.VK_RIGHT:
                 SpielerWahl = 1;
                 setColorRechts(new int[]{0, 127, 0});
                 controller.sleep(1000);
                 setColorRechts(new int[]{0, 80, 0});
                 controller.updateLedStripe();
                 Spieler.add(SpielerWahl);
                 break;
               case java.awt.event.KeyEvent.VK_DOWN:
                 // Pruefung auf den Bildrand
                 SpielerWahl = 2;
                 setColorUnten(new int[]{127, 127, 0});
                 controller.sleep(1000);
                 setColorUnten(new int[]{80, 80, 0});
                 controller.updateLedStripe();
                 Spieler.add(SpielerWahl);
                 break;
               case java.awt.event.KeyEvent.VK_LEFT:
                 // Pruefung auf den Bildrand
                 SpielerWahl = 3;
                 setColorLinks(new int[]{0, 0, 127});
                 controller.sleep(1000);
                 setColorLinks(new int[]{0, 0, 80});   
                 controller.updateLedStripe();
                 Spieler.add(SpielerWahl);
                 break;
               default:
             }
           }
         }

         // Eingaben des Spielers und des Computers in der Konsole anzeigen.
         System.out.println("Eingabereihenfolge des Co. " + Computer);
         System.out.println("Eingabereihenfolge des Sp. " + Spieler);
       }
     } while(Vergleichen(Spieler, Computer));
   }

   // Methode um die Arrays Spieler und Computer vergleichen zu können.
   public static boolean Vergleichen(ArrayList<Integer> List1, ArrayList<Integer> List2) {
     boolean flag = false;
     for (int i = 0; i < List1.size(); i++) {
       if (List1.get(i) == List2.get(i)) {
         flag = true;
       } else {
         flag = false;
       }
     }
     return flag;
   }

    public static void setColorOben(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i =2; i<6;i++){                       
            for(int j =1;j<i;j++){
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for(int i =6; i <10;i++){                     
            for(int j = 1; j<11-i;j++){
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorLinks(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i =1; i<5;i++){
            for(int j =2;j<6;j++){
                if(j>i){
                controller.setColor(i, j, color[0], color[1], color[2]);
                    }
                }
            }
            for( int i = 5;i>0;i--){                      
                for(int j = 6;j<11-i;j++){
                    controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorRechts(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i = 7; i<11; i++){                   
            for(int j = 5;j>11-i;j--){
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for(int i = 7;i<11;i++){                    
            for(int j=6;j<i;j++){
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorUnten(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i =6; i<10;i++){           
            for(int j =10;j>i;j--){
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for( int i =2; i<=5;i++){
            for(int j =10;j>11-i;j--){                 
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setRandColor(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i =0;i<12;i++){                        
            controller.setColor(i, 0, 40, 40, 40);
            controller.setColor(0, i, 40, 40, 40);
            controller.setColor(i, 11, 40, 40, 40);
            controller.setColor(11, i, 40, 40, 40);
        }
        controller.updateLedStripe();
    }

    public static void setDiagonalColor(int[] color){
   
        controller = BoardController.getBoardController();
   
        for(int i=1;i<11;i++){                       
            for(int j = 1;j < 11;j++){
                if(i==j){
            controller.setColor(j, i, color[0], color[1], color[2]);
                }
        }
        }
        for(int i=1;i<11;i++){                         
            for(int j = 11;j >0;j--){
                if(i+j==11)
            controller.setColor(j, i, color[0], color[1], color[2]);
            }
            }
        controller.updateLedStripe();
}}

 

[Joose]

       while(Spieler.size() < Computer.size()) {
         // Das letzte KeyEvent wird aus dem Buffer gelesen.
         KeyEvent event = buffer.pop();
.....
       }

In dieser Schleife ergänzt du die bisherige Eingaben des Spielers einfach nur um die neuerst und die Bedingung ist schon erfüllt. Du musst aber nach der Schleife die Auswahl des Spielers wieder komplett leeren.

 

[BD85]

       while(Spieler.size() < Computer.size()) {
         // Das letzte KeyEvent wird aus dem Buffer gelesen.
         KeyEvent event = buffer.pop();
.....
       }

In dieser Schleife ergänzt du die bisherige Eingaben des Spielers einfach nur um die neuerst und die Bedingung ist schon erfüllt. Du musst aber nach der Schleife die Auswahl des Spielers wieder komplett leeren.

Danke für den Hinweis. Ich habe die Leerung des Spieler Arrays jetzt in die Vergleichen Methode vor dem return flag; implementiert, sodass nach jeder erfolgreichen Eingabe das Spieler Array wieder geleert wird und die ComputerWahl+1 von Beginn an erneut eingegeben werden muss.

Jetzt hat sich ein letztes Problem herauskristallisiert. Und zwar, wenn die Spielereingabe nicht korrekt ist, müsste das Programm ja sofort stoppen und von vorne beginnen. Auch das habe ich in der Vergleichen Methode implementiert. Wenn flag = true; List2.clear(); else{ List.clear(); List1.clear(); List2.clear();}
Jedoch wird das im Programmablauf nicht berücksichtigt. Stattdessen wird das Computer Array einfach erweitert, obwohl es bereits nach der ersten falschen Eingabe hätte abbrechen müssen. Hat diesbezüglich jemand einen Lösungsansatz oder kann mir verraten, warum das nicht berücksichtigt wird?

Vielen Dank im Voraus.

 

[Joose]

Jetzt hat sich ein letztes Problem herauskristallisiert. Und zwar, wenn die Spielereingabe nicht korrekt ist, müsste das Programm ja sofort stoppen und von vorne beginnen. Auch das habe ich in der Vergleichen Methode implementiert. Wenn flag = true; List2.clear(); else{ List.clear(); List1.clear(); List2.clear();}
Jedoch wird das im Programmablauf nicht berücksichtigt. Stattdessen wird das Computer Array einfach erweitert, obwohl es bereits nach der ersten falschen Eingabe hätte abbrechen müssen. Hat diesbezüglich jemand einen Lösungsansatz oder kann mir verraten, warum das nicht berücksichtigt wird?

Wird eh berücksichtigt deine innere do/while-Schleife bricht bei einer falschen Antwort ab. (das Ergebnis von "vergleichen" wird als berücksichtigt)
Die äußere läuft aber natürlich normal weiter. Du solltest den Rückgabewert von vergleichen auf eine Variable schreiben und diese bei der außeren Schleife ebenfalls prüfen 😉

boolean compareResult = false;
....
} while(compareResult = Vergleichen(Spieler, Computer));

 

[BD85]

Vielen Dank für die Unterstützung. Nachdem ich mir Tag und Nacht den Kopf zerbrochen habe, habe ich endlich eine Lösung gefunden und das Spiel funktioniert wie gewünscht. 😀

import ledControl.BoardController;
import java.awt.event.KeyEvent;
import ledControl.gui.KeyBuffer;
import java.util.ArrayList;
import java.util.Random;

public class NewLEDProjekt {

    private static BoardController controller;

    private static KeyBuffer buffer;

    public NewLEDProjekt() {

    }

    public static void main(String[] args) {

        // Den Boardcontroller anfordern

        controller = BoardController.getBoardController();

        // Danach den KeyBuffer anfordern

        buffer = controller.getKeyBuffer();

        // Standard LED Board Farben werden gesetzt

        // Blaues Farbfeld

        setColorLinks(new int[] { 0, 0, 80 });

        // Rotes Farbfeld

        setColorOben(new int[] { 80, 0, 0 });

        // Grünes Farbfeld

        setColorRechts(new int[] { 0, 80, 0 });

        // Gelbes Farbfeld

        setColorUnten(new int[] { 80, 80, 0 });

        // Restlichen LEDs

        setRandColor(new int[] { 40, 40, 40 });

        setDiagonalColor(new int[] { 40, 40, 40 });
        controller.updateLedStripe();

        // Feld, welches der Spieler drückt

        int SpielerWahl;

        // Feld, welches der Computer drückt

        int ComputerWahl;

        // Zufallsgenerierte Zahl

        Random Zufallszahl = new Random();

        // Speicher für die vom Computer gedrückten Felder

        ArrayList<Integer> Computer = new ArrayList<Integer>();

        // Speicher für die vom Spieler gedrückten Felder

        ArrayList<Integer> Spieler = new ArrayList<Integer>();

        // das Aufleuchten der vom Computer gewählten Farben

        do {
            ComputerWahl = Zufallszahl.nextInt(4);

            Computer.add(ComputerWahl);

            for (int i = 0; i < Computer.size(); i++) {

                if (Computer.get(i) == 0) {

                    setColorOben(new int[] { 127, 0, 0 });
                    controller.sleep(1000);
                    setColorOben(new int[] { 80, 0, 0 });
                    controller.updateLedStripe();
                } else if (Computer.get(i) == 1) {

                    setColorRechts(new int[] { 0, 127, 0 });
                    controller.sleep(1000);
                    setColorRechts(new int[] { 0, 80, 0 });
                    controller.updateLedStripe();
                } else if (Computer.get(i) == 2) {

                    setColorUnten(new int[] { 127, 127, 0 });
                    controller.sleep(1000);
                    setColorUnten(new int[] { 80, 80, 0 });
                    controller.updateLedStripe();
                } else if (Computer.get(i) == 3) {

                    setColorLinks(new int[] { 0, 0, 127 });
                    controller.sleep(1000);
                    setColorLinks(new int[] { 0, 0, 80 });
                    controller.updateLedStripe();
                }
            }

            // Spielereingaben

            // Endlosschleife

            while (Spieler.size() < Computer.size()) {

                // Das letzte KeyEvent wird aus dem Buffer gelesen.

                KeyEvent event = buffer.pop();
                while (event == null) {
                    event = buffer.pop();
                }

                // Wenn eine Eingabe vorliegt, wird geprueft, ob es sich um ein
                // KEY_PRESSED-Event handelt, da dieses Programm nur auf das
                // druecken, nicht auf das loslassen einer Taste reagieren soll.

                if (event.getID() == java.awt.event.KeyEvent.KEY_PRESSED) {

                    // Wenn ein KEY_PRESSED-Event vorliegt, wird geprueft, ob es
                    // sich
                    // um eine der vier Pfeiltasten handelt.

                    switch (event.getKeyCode()) {
                    case java.awt.event.KeyEvent.VK_UP:

                        SpielerWahl = 0;
                        setColorOben(new int[] { 127, 0, 0 });
                        controller.sleep(1000);
                        setColorOben(new int[] { 80, 0, 0 });
                        Spieler.add(SpielerWahl);
                        break;

                    case java.awt.event.KeyEvent.VK_RIGHT:

                        SpielerWahl = 1;
                        setColorRechts(new int[] { 0, 127, 0 });
                        controller.sleep(1000);
                        setColorRechts(new int[] { 0, 80, 0 });
                        Spieler.add(SpielerWahl);
                        break;

                    case java.awt.event.KeyEvent.VK_DOWN:
                      
                        SpielerWahl = 2;
                        setColorUnten(new int[] { 127, 127, 0 });
                        controller.sleep(1000);
                        setColorUnten(new int[] { 80, 80, 0 });
                        Spieler.add(SpielerWahl);
                        break;

                    case java.awt.event.KeyEvent.VK_LEFT:
                      
                        SpielerWahl = 3;
                        setColorLinks(new int[] { 0, 0, 127 });
                        controller.sleep(1000);
                        setColorLinks(new int[] { 0, 0, 80 });
                        Spieler.add(SpielerWahl);
                        break;
                    default:
                    }
                    System.out.println(Spieler.size() + " " + Computer.size());
                    if (Spieler.get(Spieler.size() - 1) != Computer.get(Spieler
                            .size() - 1)) {
                        Spieler.clear();
                        Computer.clear();
                        for (int f = 0; f < 3; f++) {                      // farbliche Fehleranzeige: 3 mal Diagonal + Rand rot blinken
                            setDiagonalColor(new int[] { 100, 0, 0 });
                            setRandColor(new int[] { 100, 0, 0 });
                            controller.updateLedStripe();

                            controller.sleep(600);
                            setDiagonalColor(new int[] { 40, 40, 40 });
                            setRandColor(new int[] { 40, 40, 40 });
                            controller.updateLedStripe();
                            controller.sleep(1000); // kurze Pause
                        }
                    }
                    controller.updateLedStripe();
                }
            }

            // Eingaben des Spielers und des Computers in der Konsole anzeigen.

            System.out.println("Eingabereihenfolge des Co. " + Computer);
            System.out.println("Eingabereihenfolge des Sp. " + Spieler);
            Spieler.clear();
        } while (true);
    }

    // Methode um die Arrays Spieler und Computer vergleichen zu können.

    public static void setColorOben(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 2; i < 6; i++) {
            for (int j = 1; j < i; j++) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for (int i = 6; i < 10; i++) {
            for (int j = 1; j < 11 - i; j++) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorLinks(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 1; i < 5; i++) {
            for (int j = 2; j < 6; j++) {
                if (j > i) {
                    controller.setColor(i, j, color[0], color[1], color[2]);
                }
            }
        }
        for (int i = 5; i > 0; i--) {
            for (int j = 6; j < 11 - i; j++) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorRechts(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 7; i < 11; i++) {
            for (int j = 5; j > 11 - i; j--) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for (int i = 7; i < 11; i++) {
            for (int j = 6; j < i; j++) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setColorUnten(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 6; i < 10; i++) {
            for (int j = 10; j > i; j--) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        for (int i = 2; i <= 5; i++) {
            for (int j = 10; j > 11 - i; j--) {
                controller.setColor(i, j, color[0], color[1], color[2]);
            }
        }
        controller.updateLedStripe();
    }

    public static void setRandColor(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 0; i < 12; i++) {
            controller.setColor(i, 0, 40, 40, 40);
            controller.setColor(i, 0, color[0], color[1], color[2]);
            controller.setColor(0, i, 40, 40, 40);
            controller.setColor(0, i, color[0], color[1], color[2]);
            controller.setColor(i, 11, 40, 40, 40);
            controller.setColor(i, 11, color[0], color[1], color[2]);
            controller.setColor(11, i, 40, 40, 40);
            controller.setColor(11, i, color[0], color[1], color[2]);
        }
      
    }

    public static void setDiagonalColor(int[] color) {

        controller = BoardController.getBoardController();

        for (int i = 1; i < 11; i++) {
            for (int j = 1; j < 11; j++) {
                if (i == j) {
                    controller.setColor(j, i, color[0], color[1], color[2]);
                }
            }
        }
        for (int i = 1; i < 11; i++) {
            for (int j = 11; j > 0; j--) {
                if (i + j == 11)
                    controller.setColor(j, i, color[0], color[1], color[2]);
            }
        }
      
    }
}

Jetzt muss ich nur noch den Code ein bisschen entschlacken.