mazegui.java

简单的迷宫生成算法、复杂的迷宫生成算法、简单的迷宫搜索算法、复杂的迷宫搜索算法

               
               return postBuildOptionsPanel;
       }
       
       private JPanel makeSolveOptionsPanel()
       {
               JPanel solveOptionsPanel = new JPanel();
               solveOptionsPanel.setBorder(BorderFactory.createTitledBorder("Solve Options"));
               
               GridBagLayout gridbag = new GridBagLayout();
               GridBagConstraints c = new GridBagConstraints();
               solveOptionsPanel.setLayout(gridbag);
               
               //Don't stretch Components & Align to the left
               c.fill = GridBagConstraints.NONE;
               c.anchor = GridBagConstraints.LINE_START;
               c.weightx = 1.0;
               c.weighty = 1.0;
               c.insets = new Insets(INSET_SIZE, INSET_SIZE, 0, 0);
               
               //Generate the radio buttons.
               rbtnSolveAlgorithms = new JRadioButton[4];
               rbtnSolveAlgorithms[0] = new JRadioButton("Right hand");
               rbtnSolveAlgorithms[0].setSelected(true);
               rbtnSolveAlgorithms[1] = new JRadioButton("Shortest path");
               rbtnSolveAlgorithms[2] = new JRadioButton("Dijkstra shortest path");
               rbtnSolveAlgorithms[3] = new JRadioButton("Deadend filler");


               //Put the buttons in a buttongroup
               solveButtonGroup = new ButtonGroup();
               for(JRadioButton rbutton : rbtnSolveAlgorithms)
               {
                       solveButtonGroup.add( rbutton );
               }
               
               //Add the radio buttons to the panel
               c.gridwidth = 2;
               c.gridx = 0;
               c.gridy = 0;
               solveOptionsPanel.add(new JLabel("Algorithm:"), c);
               
               //Add the radio buttons
               for(JRadioButton rbutton : rbtnSolveAlgorithms)
               {
                       c.gridx = 0;
                       c.gridy++;
                       solveOptionsPanel.add(rbutton, c);
               }
               c.gridwidth = 1;
               
               
               //Solve / Stop button
               c.gridx = 0;
               c.gridy++;
               btnSolveAndPause = new JButton("Solve");
               btnSolveAndPause.setEnabled(false);
               btnSolveAndPause.addActionListener(this);
               solveOptionsPanel.add(btnSolveAndPause, c);
               
               //Reset button
               c.gridx = 1;
               btnResetSolve = new JButton("Reset solve");
               btnResetSolve.setEnabled(false);
               btnResetSolve.addActionListener(this);
               solveOptionsPanel.add(btnResetSolve, c);
               
               return solveOptionsPanel;
       }
       
       private JPanel makeBenchmarkPanel()
       {
               JPanel benchmarkPanel = new JPanel();
               benchmarkPanel.setBorder(BorderFactory.createTitledBorder("Benchmarking"));
               
               GridLayout grid = new GridLayout(2, 6);
               benchmarkPanel.setLayout(grid);
               
               lblBuildTotalLabel = new JLabel("Total Build Time: ");
               benchmarkPanel.add(lblBuildTotalLabel);
               lblBuildTotal = new JLabel("0");
               benchmarkPanel.add(lblBuildTotal);
               lblBuildTickCountLabel = new JLabel("Build Tick Count: ");
               benchmarkPanel.add(lblBuildTickCountLabel);
               lblBuildTickCount = new JLabel("0");
               benchmarkPanel.add(lblBuildTickCount);
               lblBuildTimePerTickLabel = new JLabel("Build Time Per Tick: ");
               benchmarkPanel.add(lblBuildTimePerTickLabel);
               lblBuildTimePerTick = new JLabel("0");
               benchmarkPanel.add(lblBuildTimePerTick);
               lblSolveTotalLabel = new JLabel("Total Solve Time: ");
               benchmarkPanel.add(lblSolveTotalLabel);
               lblSolveTotal = new JLabel("0");
               benchmarkPanel.add(lblSolveTotal);
               lblSolveTickCountLabel = new JLabel("Solve Tick Count: ");
               benchmarkPanel.add(lblSolveTickCountLabel);
               lblSolveTickCount = new JLabel("0");
               benchmarkPanel.add(lblSolveTickCount);
               lblSolveTimePerTickLabel = new JLabel("Solve Time Per Tick: ");
               benchmarkPanel.add(lblSolveTimePerTickLabel);
               lblSolveTimePerTick = new JLabel("0");
               benchmarkPanel.add(lblSolveTimePerTick);

               return benchmarkPanel;
       }
       
       /*
        * Function for Manager to repaint the maze display after each tick
        */
       public void repaintMazeGraph()
       {
               mazePanel.repaint();
       }
       
       /*
        * Private classes used to start worker threads.
        * (WT stands for worker thread)
        */
       private class WTStartBuild implements Runnable
       {
               private int algorithm;
               private int delay;
               
               public WTStartBuild(int a, int d)
               {
                       this.algorithm = a;
                       this.delay = d;
               }
               
               @Override
               public void run()
               {
                       Build buildAlgorithmObject;
                       switch(algorithm)
                       {
                       case 0:
                               buildAlgorithmObject = new BookBuild();
                               break;
                       case 1:
                               buildAlgorithmObject = new PathBuild();
                               break;
                       case 2:
                       default:
                               buildAlgorithmObject = new DfsBuild();
                               break;
                       }
                       
                       manager.startBuild(buildAlgorithmObject, delay);
               }
       }
       
       private class WTContinueBuild implements Runnable
       {
               private int delay;
               
               public WTContinueBuild(int d)
               {
                       this.delay = d;
               }
               
               @Override
               public void run()
               {
                       manager.continueBuild(this.delay);
               }
       }
       
       private class WTStartSolve implements Runnable
       {
               private int algorithm;
               private int delay;
               
               public WTStartSolve(int a, int d)
               {
                       this.algorithm = a;
                       this.delay = d;
               }
               
               @Override
               public void run()
               {
                       Solve solveAlgorithmObject;
                       switch(algorithm)
                       {
                       case 0:
                               solveAlgorithmObject = new RightHandSolve();
                               break;
                       case 1:
                               solveAlgorithmObject = new UnweightedShortestSolve();
                               break;
                       case 2:
                               solveAlgorithmObject = new DijkstraShortestSolve();
                               break;
                       case 3:
                       default:
                               solveAlgorithmObject = new DeadendFillSolve();
                               break;
                       }
                       
                       manager.startSolve(solveAlgorithmObject, delay);
               }
       }
       
       private class WTContinueSolve implements Runnable
       {
               private int delay;
               
               public WTContinueSolve(int d)
               {
                       this.delay = d;
               }
               
               @Override
               public void run()
               {
                       manager.continueSolve( this.delay );
               }
       }

       /**
        * Used to enable the MazeImporter functionality used for debugging.
        */
       public void enableDebugImportExport(JPanel menuPanel)
       {
               //Do some initializations
               MazeImporter.initFileChooser();
               
               
               //Open Action object
               Action openAction = new AbstractAction(){
                       private static final long serialVersionUID = 1L;


                       public void actionPerformed(ActionEvent e)
                       {
                               if(manager.isBusy())
                                       return;
                                       
                               //Load the maze
                               Maze maze = MazeImporter.loadMaze(frame);
                               
                               if(maze != null)
                               {
                                       //Update the manager
                                       manager.setMaze(maze);
       
                                       //Remove the old mazePanel
                                       frame.getContentPane().remove( mazePanel );
                                       
                                       //Insert a new mazePanel
                                       MazeGui.this.insertMazePanel(maze);
                               }
                       }
               };
               
               //Open shortcut (Ctrl + O)
               KeyStroke openStroke = KeyStroke.getKeyStroke("ctrl O");
               menuPanel.getInputMap(JPanel.WHEN_IN_FOCUSED_WINDOW).put(openStroke, "openAction");
               menuPanel.getActionMap().put("openAction", openAction);
               
               
               //Save Action object
               Action saveAction = new AbstractAction(){
                       private static final long serialVersionUID = 1L;
                       
                       public void actionPerformed(ActionEvent e) {
                               if(!manager.isBusy())
                               {
                                       MazeImporter.saveMaze(frame, maze);
                               }
                       }
               };
               
               //Save shortcut (Ctrl + S)
               KeyStroke saveStroke = KeyStroke.getKeyStroke("ctrl S");
               menuPanel.getInputMap(JPanel.WHEN_IN_FOCUSED_WINDOW).put(saveStroke, "saveAction");
               menuPanel.getActionMap().put("saveAction", saveAction);
       }
}