Puzzle - Erkennen wenn gelöst (array vergleichen)

[HansK]

Hallo,
Ich bin gerade dabei ein Puzzle-Spiel zu programmieren,
weiß aber gerade nicht weiter.
Hier meine Probleme.

1.) Das Programm soll erkennen, wann die Buttons in die richtige Reihenfolge gebracht wurden, das Puzzle also gelöst wurde, sodass eine Ausgabe gegeben werden kann ( zB "Congratulations!").
2.) Ich möchte einen "Reset" Menüpunkt hinzufügen, welcher mir die Buttons neu durchwürfelt.

Hier mein bisheriges Coding.
Das vergleichen müsste doch eigentlich mittels equals funktionen funktionieren oder?
Wenn ja, wo soll ich diese einbauen das das Programm auch erkennt das das Puzzle gelöst wurde?

public class PuzzlePro extends JFrame implements ActionListener {
 
    private int index;
    private JButton[] button;
    private JLabel label;
    private JLabel label2;
    
 
    public PuzzlePro() {
    
        super("Puzzle Pro");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize( 800, 600);
        setResizable ( false );
        setLocationRelativeTo(null);
        JPanel panel = new JPanel(new GridLayout(3,3));
        index = -1;
        
        button = new JButton[10];
        for (int i=1; i<button.length; i++) {
            button[i] = new JButton();
            button[i].addActionListener(this);
            button[i].setIcon(new ImageIcon(getClass().getResource("berg"+i+i+".jpg")));
 
        }
        
        for(int i = 1; i < button.length; i++){
                JButton tmp = button[i];
                int zelle = (int) (Math.random()*(button.length - i) + i);
                button[i] = button[zelle];
                button[zelle] = tmp;
                }
                
        for(int i = 1; i < button.length; i++){
                panel.add(button[i]);
                button[i].setVisible(false);
                }
        
        this.getContentPane().add(panel, BorderLayout.CENTER);
        this.getContentPane().add(label = new JLabel("Erstes Bild wählen"), BorderLayout.SOUTH);
 
    JMenu menu, submenu;
    JMenuItem menuItem;
    JMenuBar menuBar = new JMenuBar();
    
        menu = new JMenu( "GAME");          // Erzeugen eines Hauptmenüpunktes
    menuBar.add( menu);                       // Hinzufügen des Hauptmenüpunktes
    menuItem = new JMenuItem( "New Game"); // Erzeugen eines Untermenüs von Puzzle Pro
    menu.add(menuItem);
 
    menuItem.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e) {
              for (int i = 1; i < button.length; i++) {
              button[i].setVisible(true);
              }
      }
    });
    menuItem = new JMenuItem( "Exit");                    // Erzeugen eines Untermenüs von Puzzle Pro
    menu.add(menuItem);                                   // Untermenü wird dem Hauptmenü hinzugefügt
    menuItem.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e) {
        System.exit(0);                                      // Durch wählen des Menupunketes "Exit" wird das Fenster beendet
      }
    });
 
    menu = new JMenu( "Optionen");           // Erzeugen eines Hauptmenüpunktes
    menuBar.add( menu);                        // Hinzufügen des Hauptmenüpunktes
    
    menuItem = new JMenuItem( "Hilfe");
    menu.add(menuItem);
    menuItem.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e) {
        try
        {
        Desktop.getDesktop().open(new File("Hilfe.txt"));
        }
        catch(Exception eref)
        {
        }
      }
    });
    menuItem = new JMenuItem( "Handbuch"); // Erzeugen eines Untermenüs von Puzzle Pro
    menu.add(menuItem);
    menuItem.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e) {
        try
        {
        Desktop.getDesktop().open(new File("Handbuch.pdf"));
        }
        catch(Exception eref)
        {
        }
      }
    });
    menuItem = new JMenuItem( "About"); // Erzeugen eines Untermenüs von Puzzle Pro
    menu.add(menuItem);
    menuItem.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e) {
             JOptionPane.showMessageDialog(null, "                                         ", "About", JOptionPane.CLOSED_OPTION);
      }
    });
 
    setJMenuBar( menuBar);                  // Erzeugen der kompletten Menüleiste
    }
 
    public void actionPerformed(ActionEvent e) {
        int curIndex = -1;
        for (int i=0; i<button.length; i++) {
            if (e.getSource().equals(button[i])) {
                curIndex = i;
                break;
            }
        }
        if(index==-1) {
            index = curIndex;
            label.setText(" Zweites Bild wählen");
        }
        else {
            swapIcons(index, curIndex);
            index = -1;
            label.setText(" Erstes Bild wählen");
        }
    }
 
    private void swapIcons(int index1, int index2) {
        Icon icon = button[index1].getIcon();
        button[index1].setIcon(button[index2].getIcon());
        button[index2].setIcon(icon);
    }
 
    public static void main(String[] args) {
        JFrame frame = new PuzzlePro();
        frame.setVisible(true);
    }
}

Ich hoffe auf Tips und Codingbeispiele.

Gruß,
Hans

 

[diggaa1984]

hm .. da du ja die Icons der Buttons änderst um ein Verschieben oder Ändern zu visualisieren .. ists mit'm Vergleichen eher schwierig. Die eigentlichen Buttonobjekte behalten ja ihre Position, nur das Bild der Buttons wird geändert, dass heisst du kannst schonmal nicht mit einer Reihenfolge der Buttons als Vergleich arbeiten.

Ich persönlich hätte im ersten anlauf, die Buttons sortiert in einer Datenstruktur abgelegt .. in dieser Struktur ändert sich die Reihenfolge nicht .. dann hätte ich wohl die Buttons zufällig verteilt. Diese Verteilung würde in einer zweiten Datenstruktur abgelegt werden, und diese Struktur würde sich beim Verschieben mit ändern, sodass diese immer den aktuellen Zustand widerspiegelt. Dann kannst du bei jedem Verschieben die 2 Strukturen vergleichen, wenn die 2. mit der 1. übereinstimmt, ist das Ding gelöst.
Je nachdem welche Daten du in der 2. Struktur ablegst kannst du auch erreichen, dass du lediglich den Inhalt der 2. Struktur prüfst und damit entscheidest ob alles korrekt verschoben wurde, indem sone Art Indizes der Bilder gespeichert werden. Das erste Bild muss dann bspw das erste Element in der Struktur sein. das. zweite Bild das 2. Element etc. Da brauchst du kein Vergleich mit der ersten Struktur durchführen.

Das ist wie gesagt meine erste Idee, die mir in den Sinn kommt .. aber gibt bestimmt noch originellere Sachen

 

[Michael...]

Hatte Dir ja in den anderen Postings gesagt, dass Du mit der Vorgehensweise nicht wirklich glücklich werden wirst und dass beim direkten Tauschen der Icons von Button zu Button die Überprüfung später erschwert.

Es ist zwar möglich eine Liste/Array der Icons in richtiger Reihefolge vorzuhalten und die mit den Icons auf den Buttons gegenzuchecken.
Meine Empfehlung gilt aber immer noch: Fange mit einem einfachen Modell an das nur Zahlen statt Icons benutzt. Wenn das mal läuft kann man das relativ einfach erweitern und auf Basis der Zahlen im Model die Icons auf den Buttons setzen.

 

[HansK]

Vielen Dank digga und Michael, Ich werde versuchen das erstmal mit normalen Zahlen umzusetzen!
(Nochmal danke für die unglaublich guten Tips von davor @Michael)

 

[HansK]

Wie könnte man das mit dem Reset Button lösen?
Das Problem ist ja das die Bilder dann fest gesetzt werden
Kann ich die nachträglich auch nochmal shufflen?

 

[diggaa1984]

hm in meinem fall hätte ich einfach wieder die reihenfolge in der 2. struktur geshuffled und dann die bilder der reihenfolge nach auf die buttons gelegt. ist ja nix anderes als beim ersten shufflen.

 

[HansK]

kannst du dazu vlt ein kleines coding beispiel geben?
wie soll ich das dann in den actionlistener schreiben?

 

[diggaa1984]

joa ich würd mal was minimales probieren ... "kleinen" moment mal

 

[diggaa1984]

so hab nun mal was .. ohne das verschieben realisiert nur das ändern der komponenten und ich bin bei zahlen geblieben

import javax.swing.SwingUtilities;

public class MainClass {
	
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				MyFrame frame = new MyFrame();
				frame.setVisible(true);
			}
		});
	}
}

import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;


public class MyFrame extends JFrame {

	private JButton[] buttons;
	private List<Integer> indices;
	
	public MyFrame() {
		super();
		setup();
		shuffle();
	}
	

	private void setup() {
		buttons = new JButton[9];
		indices = new ArrayList<Integer>();
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLayout(new GridLayout(3,3));
		
		for(int i=0; i<9; i++) {
			buttons[i] = new JButton("-");
			buttons[i].setPreferredSize(new Dimension(50,50));
			add(buttons[i]);
			indices.add(i);
		}//for
		
		setupMenu();
		pack();
	}
	
	
	private void setupMenu() {
		JMenuBar bar = new JMenuBar();
		JMenu m = new JMenu("Edit");
		JMenuItem mi = new JMenuItem("Reset");
		mi.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				MyFrame.this.shuffle();
			}
		});
		
		m.add(mi);
		bar.add(m);
		
		setJMenuBar(bar);
	}
	
	
	private void shuffle() {
		Collections.shuffle(indices);
		for(int i=0; i<9; i++) {
			buttons[i].setText(String.valueOf(indices.get(i)));
		}
	}
	
}

 

[HansK]

Danke diggaa hab es endlich hinbekommen!
Das einzige Problem was ich jetzt noch habe ist, wie ich das Programm erkennen lasse das es gelöst wurde.
Kann man ein weiteres array mit der "richtigen" reihenfolge festlegen und mittels equals funktion das geshuffelte array+ das richtige array vergleichen und dann eine ausgabe machen ( popup)??
bzw wie vergleiche ich die icons auf den buttons?
gruß hans

 

[diggaa1984]

ja na irgendwo muss es direkt oder indirekt ne reihenfolge-information geben .. bei den zahlen war es so gedacht, dass es korrekt ist, wenn die 0 an [0] steht und die 1 an [1] und die 2 an [2] etc. ... mit bildern bzw komplexen Daten ist das da eben net ganz so simpel

du kannst dir ja erstmal eine Liste oder ein Array in der korrekten Reihenfolge anlegen, das bleibt unangetastet im gesamten Verlauf .. dann die 2. Struktur welche den aktuellen Zustand darstellt und prüfst die beiden strukturen gegeneinander.

weitere variante wäre:
Damit du nun nicht nach jedem Verschieben das gesamte Feld und damit alle Bilder durchlaufen und prüfen musst (weil sich ja immer nur 2 Einträge ändern können) .. könntest du zB noch eine Counter mitlaufen lassen, der angibt wieviele Bilder an der falschen Stelle sind .. vertauscht man nun 2 Bilder, so musst du nur diese 2 Positionen prüfen und erhöhst/verringerst den Counter oder lässt ihn wie er ist .. ist der Counter 0, ist alles korrekt verschoben.

Konstellationen:

• verschieben 2er Bilder ohne das eines Richtig ist und bereits an alter position falsch war ... counter bleibt gleich
  
• verschieben 2er Bilder wobei 1 korrekt ist und 1 falsch (beide waren an alter position bereits falsch) ... counter verringert sich um 1
  
• verschieben 2er Bilder wobei nun beide korrekt sind ... counter verringert sich um 2
  
• verschieben eines korrekten Bildes (wird dann quasi an falsche position geschoben) .. wobei das ersatzbild auch falsch ist und an alter position auch falsch war .. counter erhöht sich um 1
  
• verschieben zweier korrekten Bilder ... counter erhöht sich um 2

somit hast alles möglich erfasst. Wenn man nur 9 Bilder hat, mag dieses System nicht notwendig sein, da man auch 9 Bilder jederzeit komplett überprüfen kann ... aber wenn du 100*100 hast oder weiss der geier wieviel, ist das schon ne ersparnis auch nur das zu prüfen was sich geändert hat


EDIT: ob man arrays per equals vergleichen kann .. nicht wie du das gern hättest! .. du musst in dem fall alle einträge der selben position miteinander vergleichen