Battleship Game Engine

The Battleship Game Engine (BGE) implements the classic turn-based board game as a package that's separated from any presentation layer. This architectural pattern is useful in many applications since it allows any number of apps to utilize the same service.

This advanced project demonstrates:

• Separation of Concerns: Game logic completely independent from UI
• API-like Interface: Function-based interaction similar to REST APIs
• State Management: Comprehensive game state tracking and validation
• Algorithm Implementation: Ship placement, collision detection, and game mechanics
• Scalable Architecture: Design patterns that support multiple presentation layers

Key Components to Implement:

Core Game Engine (BGE)

• Game Initialization: startGame() function that:

  • Generates an 8x8 game board
  • Randomly places 3 ships (Destroyer: 2, Cruiser: 3, Battleship: 4 squares)
  • Returns ship placement array for testing/debugging
  • Supports configurable board dimensions (bonus)

• Shooting Mechanics: shoot(row, col) function that:

  • Validates target coordinates
  • Determines hit or miss
  • Updates hits and misses array
  • Tracks remaining ships
  • Returns comprehensive game state

• Game State Tracking: Maintain arrays showing:

  • Ship placements (for internal logic)
  • Hits and misses ( = untargeted, O = miss, X = hit)
  • Number of ships remaining
  • Game completion status

Text-Based Presentation Layer

• Visual Display: 2D character representation of the game board
• User Input: Coordinate input system with validation
• Game Flow: Turn-based interaction with clear prompts
• Feedback System: Hit/miss indicators and game status updates
• Replay Functionality: Option to play multiple games

Advanced Features (Bonus)

• Flexible Configuration: Customizable board size and ship counts
• Game Statistics: gameStats() function returning metrics
• Multiplayer Support: Two-player game mechanics
• Enhanced UI: Player-specific displays and turn indicators

Technical Challenges:

• Implementing random ship placement without overlaps
• Designing clean API interfaces between engine and presentation
• Managing complex game state across multiple interactions
• Creating flexible, reusable architecture
• Handling edge cases and input validation

Learning Outcomes:

• Software architecture and design patterns
• API design and separation of concerns
• Game algorithm implementation
• State management best practices
• Test-driven development (since engine is testable independently)

This project teaches fundamental software engineering principles while creating a sophisticated game engine that can power multiple different user interfaces.