Star-Odyssey

Inspiration

A shared frustration inspired us with conventional narrative games:

choices often feel superficial, and NPCs behave like static quest dispensers.

We wanted to build something closer to a sandbox narrative simulation—a small but coherent world where:

characters remember past events
relationships evolve over time
resources actually matter
urgency is real
outcomes are not pre-scripted

Rather than building a massive open world, we intentionally constrained scope into a 3-day crisis scenario aboard a spaceship. This allowed us to focus deeply on causality, consistency, and character logic.

What it does

Star-Odyssey simulates a living world: NPCs possess independent goals, secrets, and relationships, and the game world evolves dynamically based on player actions and internal character decisions.

Instead of pre-written dialogue trees, the story emerges from AI reasoning over world state, character motivations, and resource constraints.

Our goal was to explore how large language models can be used not just to generate text, but to simulate believable systems and social dynamics inside games.

How we built it

We designed a three-layer architecture:

Frontend (React + Vite)
    ↕
Game Engine (Python Backend)
    ↕
AI Layer (Google Gemini)

Gemini Tools Used

Google Gemini API (via an API key from ai.google.dev)
Gemini-powered text generation for:
- Dynamic narration (contextual story responses to player choices)
- Random event / crisis generation
- Consequence generation (emergent outcomes from decisions)
- NPC decision-making (AI-driven autonomous crew actions / behavior)
- ORACLE system (ship AI dialogue that evolves toward “sentience” through interaction)

Challenges we ran into

LLMs tend to hallucinate. Without strict structure, the world quickly becomes incoherent.

We solved this by introducing:

explicit state variables
rule validation
event schemas
deterministic turn resolution

Accomplishments that we're proud of

Multi-agent AI + frontend + backend + deployment is non-trivial under hackathon time pressure.

We adopted:

strict scope boundaries
small world design
modular services
rapid iteration cycles

Letting NPCs act freely often undermines player agency.

We balanced this by:

limiting NPC action scope per turn
exposing consequences transparently
allowing player intervention at key moments

What we learned

This project taught us that AI game design is less about prompting and more about system design.

Some key learnings:

LLMs need explicit state representations to remain consistent over time.
NPC autonomy requires guardrails — pure generation leads to chaos.
Rules Engines are essential for validating AI outputs before mutating game state.
Multi-agent systems quickly become complex without structured orchestration.
Frontend UX matters just as much as backend intelligence for player immersion.

Most importantly, we learned that AI becomes powerful when embedded inside constraints, not when left unconstrained.