HOLMES

An AI-powered Interactive Detective Game

Inspiration

HOLMES was born out of a deep appreciation for classic detective fiction and interactive storytelling. Our aim was to blend the intellectual thrill of mystery-solving with modern AI capabilities, allowing players to embody the role of a detective in a dynamic, choice-driven narrative world.

Overview

HOLMES is a story-rich, interactive detective game where players investigate mysteries by engaging with a cast of unique non-player characters (NPCs), gathering evidence, and making decisions that shape the unfolding narrative. Each case is a new challenge, with branching storylines and multiple outcomes.

The game is built on a modular storytelling engine that powers complex interactions, evolving scenarios, and adaptive plotlines. Players interact with the game through a frontend interface that presents immersive choices and real-time feedback.

Technologies Used

Python: Core game logic and modular architecture.
Letta: Used for structured narrative generation and orchestration.
Nitrode: Powers real-time event handling and game state synchronization.
Gemini: Enables intelligent dialogue and adaptive character responses.
Custom Frontend Framework: Designed for clean user interaction.
Unit Testing Framework: Ensures code reliability (test_game.py).

Architecture & Components

The codebase is structured for scalability, maintainability, and ease of extension:

Game.py & Game_Simple.py: Handle the main game loop and logic.
Controller.py & Controller_Simple.py: Manage user input and game flow.
NPC.py & NPC_Simple.py: Define NPC behavior and interactions.
Watson.py & Watson_Simple.py: Introduce an AI companion to assist the player.
Story_Teller.py: Generates and manages adaptive narrative threads.
frontend/: User-facing interface for decision-making and feedback.
test_game.py: Comprehensive testing for reliability and future development.

Challenges Faced

Designing a flexible story engine that adapts meaningfully to player decisions while maintaining a coherent narrative.
Managing the complexity of autonomous NPC behavior without breaking immersion.
Integrating the frontend with the backend in a way that ensures seamless transitions and responsiveness.
Balancing modularity with tight control over the game's flow and pacing.

Key Achievements

Developed a modular, extensible game framework that supports easy content updates.
Built a dynamic narrative engine that reacts to player choices in real-time.
Integrated multiple components (AI, logic, frontend) into a cohesive, playable experience.
Established a robust testing system to maintain code integrity and future scalability.

Lessons Learned

This project deepened our understanding of interactive game design, narrative systems, and modular development in Python. We learned how to effectively integrate AI tools into gameplay and how to manage a large codebase across multiple components. Most importantly, we gained insight into building meaningful player experiences through storytelling and interaction.