Researcher

AI Agent For Sliding Puzzle Game

Project Image
Project Image
Project Image
Project Image
Project Image
Project Image
Project Image
Project Image
Project Image
Project Image
Project Image

Undergraduate Project

Principal Supervisors

  1. Eng. Yaalini Balathasan

Group Members

  1. Indushan Senavirathna
  1. Nuwarawewa S.W.N.W.B.B
  1. Nirmani B.G.M

We have developed a Python program that addresses the problem of finding a combination of moves that leads to the goal state in a sliding puzzle game. The game involves rearranging puzzle pieces by sliding them around on a board until the picture is complete. The puzzle pieces can be moved one at a time, and the movement is performed by clicking on the desired piece.

Our program features a graphical user interface (GUI) that allows players to interact with the game through mouse clicks. The GUI provides visual feedback and keeps track of the number of moves made during the gameplay.

To solve the puzzle, we have implemented two search algorithms: breadth-first search and best-first search. These algorithms systematically explore different combinations of moves to find the optimal solution. By applying these search strategies, our program is able to determine a sequence of moves that leads from the given board state to the desired goal state.

In addition to the search algorithms, our program offers the functionality to customize the initial game state using a CSV file. This allows users to create their own puzzle configurations or load predefined setups.

Overall, our program provides an interactive and efficient solution to the sliding puzzle game, allowing players to enjoy the challenge of rearranging puzzle pieces while keeping track of their progress.

  1. Design the game structure: Start by defining the structure of the sliding puzzle game. Decide on the size of the puzzle board (e.g., 3x3, 4x4) and determine how you will represent the game state.
  2. Handle user input: Implement the functionality to handle user input through mouse clicks. Determine the clicked tile and the corresponding action to perform (e.g., moving the tile to an adjacent empty space).
  3. Track and display moves: Keep track of the number of moves made by the user and display this information on the GUI. Update the move count each time a valid move is made.
  4. Load and save game state: Implement the ability to load and save the game state using a CSV file. Define the file format to represent the puzzle configuration and implement functions to read and write this data.
  5. Implement breadth-first search (BFS) algorithm: Develop the BFS algorithm to solve the sliding puzzle. This algorithm explores all possible moves from each game state until it finds the solution. Implement a function that performs BFS, keeping track of visited states and the moves taken to reach each state.
  6. Implement best-first search (BFS) algorithm: Similarly, implement the best-first search algorithm to solve the sliding puzzle. This algorithm uses heuristics to prioritize moves that are more likely to lead to the solution. You can use a heuristic like the Manhattan distance to estimate the distance of each tile from its goal position.
  7. Integrate the search algorithms: Connect the search algorithms to the GUI. Allow the user to trigger the solving process using a button or menu option. Display the solution steps on the GUI after the search algorithm completes.
  8. Test and debug: Test your game thoroughly, including user input, loading and saving game states, and the search algorithms. Fix any bugs or issues that arise during testing.
  9. Refine and optimize: Review your code for any potential optimizations and improvements. Consider ways to enhance the user experience, such as adding animations or sound effects.

Skills

  • Python programming
  • Graphical user interface (GUI) design
  • GUI programming using libraries/frameworks like Tkinter, Pygame, or PyQT
  • Event handling and user input processing
  • Game logic implementation
  • Data handling and CSV file operations
  • Algorithmic problem-solving
  • Search algorithms (e.g., breadth-first search, best-first search, A* search)
  • Heuristic design and implementation
  • Optimization techniques (e.g., memoization, dynamic programming)
  • Machine learning integration (e.g., training models, prediction, hints)
  • Visualization and animation
  • Performance optimization and profiling
  • Debugging and bug fixing
  • Project management and task organization
  • User experience (UX) design and usability considerations
  • Testing and quality assurance
  • Data analysis and insights gathering
  • Creativity in game design and visual aesthetics
  • Documentation and communication skills for explaining your code and project.