Skip to content

Latest commit

 

History

History
80 lines (64 loc) · 4.06 KB

README.md

File metadata and controls

80 lines (64 loc) · 4.06 KB

Sudoku Game - Object-Oriented Programming Project

Overview

This implements a Sudoku game built using Java. The project explores key concepts of Object-Oriented Programming (OOP), such as inheritance, encapsulation, and modularity. The game includes both a text-based interface and a Graphical User Interface (GUI) using Java Swing. The application offers a user-friendly Sudoku gameplay experience with several features like undo/redo, difficulty selection, and save/load game functionality.

Features

  • Multiple Difficulty Levels: Offers both 4x4 (easy) and 9x9 (hard) game modes.
  • Text-Based Interface: Play using command-line inputs with options to:
    • Make moves
    • Undo/Redo moves
    • Save and load games
    • Reset the game
  • Graphical User Interface (GUI): A visually interactive interface with:
    • Number validation (with color-coded feedback for invalid entries)
    • Move history tracking
    • Dynamic difficulty selection
    • File handling for saving and loading game states
  • Undo/Redo Functionality: Implemented using stacks to track user moves.
  • Observer Pattern: Real-time updates for the GUI as game states change.

Class Design and Architecture

The design follows Object-Oriented Principles to ensure modularity and scalability. The major classes include:

Core Classes

  • Sudoku: Contains the core game logic, manages the board state, and validates moves.
  • Slot: Represents an individual cell in the Sudoku grid, encapsulating its value and state.
  • Assign: Handles user input, making tracking and managing moves easier.

Interface Classes

  • UI: Implements the text-based interface, providing functionality for making moves, saving/loading the game, and undoing/redoing.
  • SudokuGUI: Extends JPanel and implements Observer, responsible for the graphical interface and interactive features.

Additional Components

  • FileDriver: Handles saving and loading the game state from files.
  • HelpClass: Provides instructions and user guidance through a dialog box.
  • DifficultyManager: Manages the difficulty settings and game variations.

Design and Implementation Decisions

Key design choices include:

  • Modularity: Each component has a single responsibility, making the system easier to maintain and expand.
  • Use of Stacks: The undo/redo feature is implemented using stacks, a natural fit for tracking user moves.
  • Observer-Observable Pattern: The GUI is updated dynamically using the observer pattern, separating game logic from the display logic.

GUI Overview

  • Difficulty Selection: Choose between easy (4x4) and hard (9x9) puzzles.
  • Move History Panel: View previous moves and utilize undo/redo functionality.
  • Game Grid: Interactive grid where users can input their numbers.
  • File Operations: Save or load game states using a file browser.

Sudoku GUI Screenshot Sudoku UI Screenshot

How to Run

  1. Clone the repository: 
    git clone https://github.com/yourusername/sudoku-game.git
cd sudoku-game
  2. Compile and run the program: 
    javac -d bin src/*.java
java -cp bin Main

Testing

The project has been tested using both White-Box and Black-Box testing strategies:

  • White-Box Testing: Unit tests were created using JUnit to validate core game logic, such as move validation, game state updates, and more.
  • Black-Box Testing: Manual testing for the GUI and text-based UI to ensure smooth interactions and functionality.

Key tests:

  • Condition Testing: Validated logical conditions within the core methods.
  • Integration Testing: Ensured proper interaction between the Sudoku and Assign classes.
  • Usability Testing: Verified that the GUI is user-friendly and provides appropriate feedback.

Known Bugs and Limitations

  • The text color for invalid numbers does not revert after undo/redo actions.
  • The GUI is not fully responsive to window resizing.