Sliding Puzzle Game in Java

The sliding puzzle game is a classic and entertaining puzzle that has captivated people for generations. The objective of the game is to arrange the numbered tiles in the correct order by sliding them into the empty space. It seemingly simple task becomes increasingly challenging as the size of the puzzle increases.

In this section, we will explore how to create a sliding puzzle game in Java. We will cover the basic concepts of the game, the implementation of the puzzle, and the graphical user interface (GUI) using Java Swing.

Understanding the Sliding Puzzle

The sliding puzzle consists of a square grid with numbered tiles, usually arranged in random order. The grid has one empty space that allows tiles to slide into it. The goal is to rearrange the tiles by sliding them into the empty space until they are ordered sequentially.

For implementation, we will create a Puzzle class to represent the game board. The class will include methods to shuffle the tiles, move them, and check whether the puzzle is solved.

Implementation

Let's start by creating a Tile class to represent each numbered tile. Each tile will have a value and a position on the grid.

public class Tile {
    private int value;
    private int row;
    private int col;
    // Constructor and getters/setters
}

Now, let's create the Puzzle class that includes the grid, methods for shuffling, moving tiles, and checking for a solved puzzle.

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Puzzle {
    private Tile[][] grid;
    private int size;
    // Constructor, initialization, and shuffle methods
    public void moveTile(int value) {
        // Implement tile movement logic
    }
    public boolean isSolved() {
        // Check if the puzzle is solved
    }
    // Additional methods for GUI interaction
}

Creating the GUI for Puzzle

Now, we have our puzzle logic. Let's create a graphical user interface using Java Swing. We will use a JFrame to represent the game window and JButton elements for each tile.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class PuzzleGUI extends JFrame {
    private Puzzle puzzle;
    // Constructor and initialization
    private void createGUI() {
        // Implement GUI creation
    }
    private void updateUI() {
        // Update the GUI based on the current puzzle state
    }
    // ActionListener for tile buttons
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            PuzzleGUI puzzleGUI = new PuzzleGUI();
            puzzleGUI.setVisible(true);
        });
    }
}

In the createGUI method, you can create and arrange JButton elements for each tile, set their appearance, and add action listeners to handle tile movements.

Creating a complete Java program for a sliding puzzle game with a graphical user interface involves a significant amount of code. Below is a simplified version of the code, including the Tile, Puzzle, and PuzzleGUI classes. Note that the code is simplified for illustration purposes and may require further refinement for a production-level application.

File Name: PuzzleGUI.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Tile {
    private int value;
    public Tile(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
class Puzzle {
    private List<Tile> tiles;
    private int size;
    public Puzzle(int size) {
        this.size = size;
        initializePuzzle();
        shufflePuzzle();
    }
    private void initializePuzzle() {
        tiles = new ArrayList<>();
        for (int i = 1; i < size * size; i++) {
            tiles.add(new Tile(i));
        }
        // Add an empty tile with value 0
        tiles.add(new Tile(0));
    }
    private void shufflePuzzle() {
        Collections.shuffle(tiles);
    }
    public List<Tile> getTiles() {
        return tiles;
    }
    public boolean isSolved() {
        for (int i = 0; i < tiles.size() - 1; i++) {
            if (tiles.get(i).getValue() != i + 1) {
                return false;
            }
        }
        return true;
    }
    public void moveTile(int tileValue) {
        int emptyIndex = tiles.indexOf(new Tile(0));
        int tileIndex = tiles.indexOf(new Tile(tileValue));
        if (isAdjacent(emptyIndex, tileIndex)) {
            Collections.swap(tiles, emptyIndex, tileIndex);
        }
    }
    private boolean isAdjacent(int index1, int index2) {
        int row1 = index1 / size;
        int col1 = index1 % size;
        int row2 = index2 / size;
        int col2 = index2 % size;
        return (Math.abs(row1 - row2) == 1 && col1 == col2) ||
               (Math.abs(col1 - col2) == 1 && row1 == row2);
    }
}
class PuzzleGUI extends JFrame {
    private Puzzle puzzle;
    private JButton[][] buttons;
    public PuzzleGUI(int size) {
        this.puzzle = new Puzzle(size);
        createGUI();
    }
    private void createGUI() {
    setTitle("Sliding Puzzle");
    setSize(400, 400);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLayout(new GridLayout(puzzle.getTiles().size(), puzzle.getTiles().size()));
    buttons = new JButton[puzzle.getTiles().size()][puzzle.getTiles().size()];
    for (int i = 0; i < puzzle.getTiles().size(); i++) {
        for (int j = 0; j < puzzle.getTiles().size(); j++) {
            int index = i * puzzle.getTiles().size() + j;
            if (index < puzzle.getTiles().size()) {
                Tile tile = puzzle.getTiles().get(index);
                buttons[i][j] = new JButton(Integer.toString(tile.getValue()));
                buttons[i][j].addActionListener(new TileClickListener(tile));
                add(buttons[i][j]);
            }
        }
    }
}
    private void updateUI() {
        for (int i = 0; i < puzzle.getTiles().size(); i++) {
            for (int j = 0; j < puzzle.getTiles().size(); j++) {
                Tile tile = puzzle.getTiles().get(i * puzzle.getTiles().size() + j);
                buttons[i][j].setText(Integer.toString(tile.getValue()));
            }
        }
    }
    private class TileClickListener implements ActionListener {
        private Tile tile;
        public TileClickListener(Tile tile) {
            this.tile = tile;
        }
        @Override
        public void actionPerformed(ActionEvent e) {
            puzzle.moveTile(tile.getValue());
            updateUI();
            if (puzzle.isSolved()) {
                JOptionPane.showMessageDialog(PuzzleGUI.this, "Congratulations! Puzzle solved.");
            }
        }
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            PuzzleGUI puzzleGUI = new PuzzleGUI(3); // Set the puzzle size
            puzzleGUI.setVisible(true);
        });
    }
}

Output:

The code provides a basic structure for a sliding puzzle game in Java using Swing. Note that the moveTile() and isSolved() methods in the Puzzle class need to be implemented according to the specific logic of the sliding puzzle game. Additionally, we can enhance the GUI and add more features to make the game more interactive and visually appealing.

Conclusion

Creating a sliding puzzle game in Java provides a great opportunity to apply object-oriented programming principles and learn about graphical user interfaces. The project can be expanded by adding features like a timer, move counter, or different puzzle sizes. By completing this project, we will not only enhance your Java skills but also have a fun and interactive game to share with others. Happy coding!

Next TopicStrobogrammatic Number in Java

← prev next →