Model a Turn-Based Cats and Rabbits Board Game

Question

Design a turn-based board game involving cats and rabbits, detailing the rules, mechanics, and interactions between the two characters.

Codemia · Accepted Answer

### Game Overview
The game involves two types of characters: cats and rabbits. The objective for the cats is to catch the rabbits, while the rabbits aim to evade capture and survive for a set number of turns.

### Rules
1. Each player takes turns moving their character on a grid-based board.
2. Cats can move one square in any direction and can catch a rabbit by landing on its square.
3. Rabbits can move two squares in any direction but cannot move into a square occupied by a cat.
4. The game ends when all rabbits are caught or the turn limit is reached.

### Turn Management
The game operates on a turn-based system where each player alternates their moves. The following mechanics are implemented:
- **Turn Order**: Players decide who goes first, and then they alternate turns.
- **Action Choices**: On their turn, a player can either move or perform a special action (e.g., a rabbit can use a burrow to skip a turn).
- **End of Turn**: After a player completes their action, the turn passes to the other player.

### System Architecture
The game can be structured using object-oriented principles:
- **Classes**: Create classes for `Game`, `Player`, `Cat`, and `Rabbit`.
- **Game Class**: Manages the board state, player turns, and win conditions.
- **Player Class**: Represents each player and their actions.
- **Cat and Rabbit Classes**: Inherit from a common `Character` class and implement specific movement and action methods.

### Potential Challenges
1. **Collision Detection**: Ensuring that cats cannot move into the same square as another cat or rabbit.
   - **Solution**: Implement a method to check the validity of a move before executing it.
2. **Game State Management**: Keeping track of the game state and player turns.
   - **Solution**: Use a centralized game state object that updates after each turn.

### Sample Code
Here is a simple implementation of the `Cat` and `Rabbit` classes in Python:
```python
class Character:
    def __init__(self, name, position):
        self.name = name
        self.position = position

class Cat(Character):
    def move(self, new_position):
        # Logic to move cat
        pass

class Rabbit(Character):
    def move(self, new_position):
        # Logic to move rabbit
        pass
```
This code snippet defines the basic structure for the characters in the game.

Model a Turn-Based Cats and Rabbits Board Game

Asana

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Game Rules and Objectives

Game Overview

Turn-Based Mechanics

Turn Management

Submit Your Answer

Asana Software Engineer Interview Guide

Related Questions

Design a scalable Search System

Design a Video Streaming for Rippling

Design a Load Balancing Service

Design a Image Processing Service

Build a high-throughput Image Processing Pipeline