RoboRouteGUI.java

import javax.swing.*;
import java.awt.*;
import java.util.List;

public class RoboRouteGUI extends JFrame {

    private static final int SIZE = 10;

    private final JButton[][] cells =
            new JButton[SIZE][SIZE];

    private Grid grid;

    private JLabel statusLabel;
    private JLabel stepsLabel;
    private JLabel algorithmLabel;
    private JLabel gridSizeLabel;
    private JLabel nodesLabel;
    private JLabel timeLabel;

    private JButton findPathButton;
    private JButton clearPathButton;
    private JButton resetButton;

    private List<Node> currentPath;

    private Timer animationTimer;

    private int robotIndex = 0;

    private final Color EMPTY_COLOR =
            new Color(245, 248, 252);

    private final Color START_COLOR =
            new Color(60, 210, 100);

    private final Color GOAL_COLOR =
            new Color(255, 210, 50);

    private final Color OBSTACLE_COLOR =
            new Color(240, 60, 60);

    private final Color PATH_COLOR =
            new Color(70, 160, 240);

    private final Color ROBOT_COLOR =
            new Color(255, 140, 40);


    public RoboRouteGUI() {

        grid = new Grid(
                SIZE,
                SIZE
        );

        setTitle(
                "RoboRoute - Robot Path Planning Simulator"
        );

        setSize(
                1050,
                760
        );

        setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE
        );

        setLocationRelativeTo(null);

        createInterface();

        updateGridDisplay();

        setVisible(true);
    }


    private void createInterface() {

        setLayout(
                new BorderLayout(
                        10,
                        10
                )
        );

        getContentPane().setBackground(
                new Color(
                        235,
                        240,
                        246
                )
        );


        // -----------------------------
        // HEADER
        // -----------------------------

        JLabel title =
                new JLabel(
                        "ROBOROUTE",
                        SwingConstants.CENTER
                );

        title.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        30
                )
        );


        JLabel subtitle =
                new JLabel(
                        "Robot Path Planning Simulator",
                        SwingConstants.CENTER
                );

        subtitle.setFont(
                new Font(
                        "Arial",
                        Font.PLAIN,
                        16
                )
        );


        JPanel titlePanel =
                new JPanel(
                        new GridLayout(
                                2,
                                1
                        )
                );

        titlePanel.setBackground(
                new Color(
                        235,
                        240,
                        246
                )
        );

        titlePanel.add(title);
        titlePanel.add(subtitle);

        add(
                titlePanel,
                BorderLayout.NORTH
        );


        // -----------------------------
        // CENTER
        // -----------------------------

        JPanel centerPanel =
                new JPanel(
                        new BorderLayout(
                                15,
                                10
                        )
                );

        centerPanel.setBackground(
                new Color(
                        235,
                        240,
                        246
                )
        );


        // -----------------------------
        // GRID
        // -----------------------------

        JPanel gridPanel =
                new JPanel(
                        new GridLayout(
                                SIZE,
                                SIZE,
                                2,
                                2
                        )
                );

        gridPanel.setBorder(
                BorderFactory.createEmptyBorder(
                        10,
                        10,
                        10,
                        10
                )
        );


        for (int row = 0;
             row < SIZE;
             row++) {

            for (int column = 0;
                 column < SIZE;
                 column++) {

                JButton button =
                        new JButton();

                button.setFont(
                        new Font(
                                "Arial",
                                Font.BOLD,
                                18
                        )
                );

                button.setFocusPainted(false);

                button.setOpaque(true);

                button.setBorder(
                        BorderFactory.createLineBorder(
                                Color.GRAY,
                                1
                        )
                );


                final int r = row;
                final int c = column;


                button.addActionListener(
                        e -> handleCellClick(
                                r,
                                c
                        )
                );


                cells[row][column] =
                        button;

                gridPanel.add(button);
            }
        }


        centerPanel.add(
                gridPanel,
                BorderLayout.CENTER
        );


        // -----------------------------
        // INFORMATION PANEL
        // -----------------------------

        JPanel infoPanel =
                new JPanel();

        infoPanel.setPreferredSize(
                new Dimension(
                        260,
                        500
                )
        );

        infoPanel.setLayout(
                new BoxLayout(
                        infoPanel,
                        BoxLayout.Y_AXIS
                )
        );

        infoPanel.setBorder(
                BorderFactory.createCompoundBorder(
                        BorderFactory.createLineBorder(
                                Color.LIGHT_GRAY
                        ),
                        BorderFactory.createEmptyBorder(
                                15,
                                15,
                                15,
                                15
                        )
                )
        );

        infoPanel.setBackground(
                Color.WHITE
        );


        JLabel infoTitle =
                new JLabel(
                        "ROBOROUTE INFO"
                );

        infoTitle.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        20
                )
        );

        infoPanel.add(infoTitle);


        infoPanel.add(
                Box.createVerticalStrut(20)
        );


        // -----------------------------
        // LEGEND
        // -----------------------------

        JLabel legendTitle =
                new JLabel(
                        "LEGEND"
                );

        legendTitle.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        16
                )
        );

        infoPanel.add(legendTitle);


        infoPanel.add(
                Box.createVerticalStrut(10)
        );


        addLegendItem(
                infoPanel,
                START_COLOR,
                "Start"
        );

        addLegendItem(
                infoPanel,
                GOAL_COLOR,
                "Goal"
        );

        addLegendItem(
                infoPanel,
                OBSTACLE_COLOR,
                "Obstacle"
        );

        addLegendItem(
                infoPanel,
                PATH_COLOR,
                "A* Path"
        );

        addLegendItem(
                infoPanel,
                ROBOT_COLOR,
                "Robot"
        );


        infoPanel.add(
                Box.createVerticalStrut(20)
        );


        // -----------------------------
        // PATH INFORMATION
        // -----------------------------

        JLabel pathTitle =
                new JLabel(
                        "PATH INFORMATION"
                );

        pathTitle.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        16
                )
        );

        infoPanel.add(pathTitle);


        infoPanel.add(
                Box.createVerticalStrut(10)
        );


        statusLabel =
                new JLabel(
                        "Status: Ready"
                );

        stepsLabel =
                new JLabel(
                        "Total Steps: -"
                );

        algorithmLabel =
                new JLabel(
                        "Algorithm: A*"
                );

        gridSizeLabel =
                new JLabel(
                        "Grid Size: 10 × 10"
                );

        nodesLabel =
                new JLabel(
                        "Nodes Explored: -"
                );

        timeLabel =
                new JLabel(
                        "Pathfinding Time: -"
                );


        Font informationFont =
                new Font(
                        "Arial",
                        Font.PLAIN,
                        14
                );


        statusLabel.setFont(
                informationFont
        );

        stepsLabel.setFont(
                informationFont
        );

        algorithmLabel.setFont(
                informationFont
        );

        gridSizeLabel.setFont(
                informationFont
        );

        nodesLabel.setFont(
                informationFont
        );

        timeLabel.setFont(
                informationFont
        );


        infoPanel.add(statusLabel);

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(stepsLabel);

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(algorithmLabel);

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(gridSizeLabel);

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(nodesLabel);

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(timeLabel);


        infoPanel.add(
                Box.createVerticalStrut(20)
        );


        // -----------------------------
        // CONTROLS
        // -----------------------------

        JLabel controlsTitle =
                new JLabel(
                        "CONTROLS"
                );

        controlsTitle.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        16
                )
        );

        infoPanel.add(controlsTitle);


        infoPanel.add(
                Box.createVerticalStrut(10)
        );


        findPathButton =
                new JButton(
                        "Find Path"
                );

        clearPathButton =
                new JButton(
                        "Clear Path"
                );

        resetButton =
                new JButton(
                        "Reset"
                );


        findPathButton.setAlignmentX(
                Component.LEFT_ALIGNMENT
        );

        clearPathButton.setAlignmentX(
                Component.LEFT_ALIGNMENT
        );

        resetButton.setAlignmentX(
                Component.LEFT_ALIGNMENT
        );


        infoPanel.add(
                findPathButton
        );

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(
                clearPathButton
        );

        infoPanel.add(
                Box.createVerticalStrut(8)
        );

        infoPanel.add(
                resetButton
        );


        infoPanel.add(
                Box.createVerticalStrut(20)
        );


        // -----------------------------
        // HOW TO USE
        // -----------------------------

        JLabel instructionTitle =
                new JLabel(
                        "HOW TO USE"
                );

        instructionTitle.setFont(
                new Font(
                        "Arial",
                        Font.BOLD,
                        16
                )
        );

        infoPanel.add(
                instructionTitle
        );


        infoPanel.add(
                Box.createVerticalStrut(8)
        );


        JLabel instructions =
                new JLabel(
                        "<html>"
                        + "1. Click cells to add obstacles.<br>"
                        + "2. Click an obstacle to remove it.<br>"
                        + "3. Click Find Path.<br>"
                        + "4. Watch the robot follow the route."
                        + "</html>"
                );


        instructions.setFont(
                new Font(
                        "Arial",
                        Font.PLAIN,
                        13
                )
        );


        infoPanel.add(
                instructions
        );


        centerPanel.add(
                infoPanel,
                BorderLayout.EAST
        );


        add(
                centerPanel,
                BorderLayout.CENTER
        );


        // -----------------------------
        // BUTTON ACTIONS
        // -----------------------------

        findPathButton.addActionListener(
                e -> findPath()
        );

        clearPathButton.addActionListener(
                e -> clearPath()
        );

        resetButton.addActionListener(
                e -> resetGrid()
        );
    }


    // -----------------------------
    // LEGEND ITEM
    // -----------------------------

    private void addLegendItem(
            JPanel panel,
            Color color,
            String text
    ) {

        JPanel item =
                new JPanel(
                        new FlowLayout(
                                FlowLayout.LEFT,
                                5,
                                2
                        )
                );

        item.setBackground(
                Color.WHITE
        );


        JLabel colorBox =
                new JLabel();

        colorBox.setOpaque(true);

        colorBox.setBackground(color);

        colorBox.setPreferredSize(
                new Dimension(
                        22,
                        22
                )
        );


        JLabel label =
                new JLabel(text);

        label.setFont(
                new Font(
                        "Arial",
                        Font.PLAIN,
                        14
                )
        );


        item.add(colorBox);
        item.add(label);

        panel.add(item);
    }


    // -----------------------------
    // CELL CLICK
    // -----------------------------

    private void handleCellClick(
            int row,
            int column
    ) {

        // Don't modify Start
        if (row == 0 &&
            column == 0) {

            return;
        }


        // Don't modify Goal
        if (row == 9 &&
            column == 9) {

            return;
        }


        if (animationTimer != null &&
            animationTimer.isRunning()) {

            animationTimer.stop();
        }


        currentPath = null;


        if (grid.isObstacle(
                row,
                column
        )) {

            removeObstacle(
                    row,
                    column
            );

        } else {

            grid.setObstacle(
                    row,
                    column
            );

            cells[row][column]
                    .setBackground(
                            OBSTACLE_COLOR
                    );

            cells[row][column]
                    .setText("");
        }


        statusLabel.setText(
                "Status: Map edited"
        );

        stepsLabel.setText(
                "Total Steps: -"
        );

        nodesLabel.setText(
                "Nodes Explored: -"
        );

        timeLabel.setText(
                "Pathfinding Time: -"
        );
    }


    // -----------------------------
    // REMOVE OBSTACLE
    // -----------------------------

    private void removeObstacle(
            int row,
            int column
    ) {

        boolean[][] obstacles =
                new boolean[SIZE][SIZE];


        for (int r = 0;
             r < SIZE;
             r++) {

            for (int c = 0;
                 c < SIZE;
                 c++) {

                obstacles[r][c] =
                        grid.isObstacle(
                                r,
                                c
                        );
            }
        }


        obstacles[row][column] =
                false;


        grid =
                new Grid(
                        SIZE,
                        SIZE
                );


        for (int r = 0;
             r < SIZE;
             r++) {

            for (int c = 0;
                 c < SIZE;
                 c++) {

                if (obstacles[r][c]) {

                    grid.setObstacle(
                            r,
                            c
                    );
                }
            }
        }


        updateGridDisplay();
    }


    // -----------------------------
    // UPDATE GRID
    // -----------------------------

    private void updateGridDisplay() {

        for (int row = 0;
             row < SIZE;
             row++) {

            for (int column = 0;
                 column < SIZE;
                 column++) {

                JButton button =
                        cells[row][column];


                button.setText("");

                button.setBackground(
                        EMPTY_COLOR
                );


                // START
                if (row == 0 &&
                    column == 0) {

                    button.setText("S");

                    button.setBackground(
                            START_COLOR
                    );
                }


                // GOAL
                else if (row == 9 &&
                         column == 9) {

                    button.setText("G");

                    button.setBackground(
                            GOAL_COLOR
                    );
                }


                // OBSTACLE
                else if (
                        grid.isObstacle(
                                row,
                                column
                        )
                ) {

                    button.setBackground(
                            OBSTACLE_COLOR
                    );
                }
            }
        }
    }


    // -----------------------------
    // FIND PATH
    // -----------------------------

    private void findPath() {

        if (animationTimer != null &&
            animationTimer.isRunning()) {

            animationTimer.stop();
        }


        updateGridDisplay();


        PathFinder pathFinder =
                new PathFinder(grid);


        long startTime =
                System.nanoTime();


        currentPath =
                pathFinder.findPath(
                        0,
                        0,
                        9,
                        9
                );


        long endTime =
                System.nanoTime();


        double elapsedTime =
                (endTime - startTime)
                / 1_000_000.0;


        // No path
        if (currentPath.isEmpty()) {

            statusLabel.setText(
                    "Status: No path found!"
            );

            stepsLabel.setText(
                    "Total Steps: -"
            );

            nodesLabel.setText(
                    "Nodes Explored: "
                    + pathFinder.getNodesExplored()
            );

            timeLabel.setText(
                    String.format(
                            "Pathfinding Time: %.3f ms",
                            elapsedTime
                    )
            );


            currentPath = null;

            return;
        }


        int steps =
                currentPath.size() - 1;


        statusLabel.setText(
                "Status: Path Found!"
        );


        stepsLabel.setText(
                "Total Steps: "
                + steps
        );


        nodesLabel.setText(
                "Nodes Explored: "
                + pathFinder.getNodesExplored()
        );


        timeLabel.setText(
                String.format(
                        "Pathfinding Time: %.3f ms",
                        elapsedTime
                )
        );


        findPathButton.setEnabled(
                false
        );


        animateRobot();
    }


    // -----------------------------
    // ROBOT ANIMATION
    // -----------------------------

    private void animateRobot() {

        robotIndex = 0;


        animationTimer =
                new Timer(
                        250,
                        null
                );


        animationTimer.addActionListener(
                e -> {

                    if (currentPath == null) {

                        animationTimer.stop();

                        return;
                    }


                    // Animation finished
                    if (robotIndex >=
                        currentPath.size()) {

                        animationTimer.stop();

                        statusLabel.setText(
                                "Status: Goal Reached! ✓"
                        );

                        findPathButton.setEnabled(
                                true
                        );

                        return;
                    }


                    // Redraw complete grid
                    updateGridDisplay();


                    // Draw path up to current position
                    for (
                            int i = 1;
                            i < robotIndex;
                            i++
                    ) {

                        Node node =
                                currentPath.get(i);


                        int row =
                                node.row;

                        int column =
                                node.column;


                        if (!grid.isObstacle(
                                row,
                                column
                        )) {

                            cells[row][column]
                                    .setBackground(
                                            PATH_COLOR
                                    );
                        }
                    }


                    // Current robot position
                    Node robotNode =
                            currentPath.get(
                                    robotIndex
                            );


                    int robotRow =
                            robotNode.row;

                    int robotColumn =
                            robotNode.column;


                    if (robotRow == 0 &&
                        robotColumn == 0) {

                        cells[robotRow][robotColumn]
                                .setText("🤖");

                    } else if (
                            robotRow == 9 &&
                            robotColumn == 9
                    ) {

                        cells[robotRow][robotColumn]
                                .setText("🤖");

                    } else {

                        cells[robotRow][robotColumn]
                                .setBackground(
                                        ROBOT_COLOR
                                );

                        cells[robotRow][robotColumn]
                                .setText("🤖");
                    }


                    robotIndex++;
                }
        );


        animationTimer.start();
    }


    // -----------------------------
    // CLEAR PATH
    // -----------------------------

    private void clearPath() {

        if (animationTimer != null &&
            animationTimer.isRunning()) {

            animationTimer.stop();
        }


        currentPath = null;


        updateGridDisplay();


        findPathButton.setEnabled(
                true
        );


        statusLabel.setText(
                "Status: Ready"
        );


        stepsLabel.setText(
                "Total Steps: -"
        );


        nodesLabel.setText(
                "Nodes Explored: -"
        );


        timeLabel.setText(
                "Pathfinding Time: -"
        );
    }


    // -----------------------------
    // RESET
    // -----------------------------

    private void resetGrid() {

        if (animationTimer != null &&
            animationTimer.isRunning()) {

            animationTimer.stop();
        }


        grid =
                new Grid(
                        SIZE,
                        SIZE
                );


        currentPath = null;


        findPathButton.setEnabled(
                true
        );


        statusLabel.setText(
                "Status: Ready"
        );


        stepsLabel.setText(
                "Total Steps: -"
        );


        nodesLabel.setText(
                "Nodes Explored: -"
        );


        timeLabel.setText(
                "Pathfinding Time: -"
        );


        updateGridDisplay();
    }


    // -----------------------------
    // MAIN
    // -----------------------------

    public static void main(
            String[] args
    ) {

        SwingUtilities.invokeLater(
                () -> new RoboRouteGUI()
        );
    }
}