https://itch.io/jam/godot-xr-game-jam-july-2024

theme: relaxation

Certainly! Here's a high-level design/architecture document summarizing our "Where's Waldo in the Sky" game concept:

---

# "Where's Waldo in the Sky" - Game Design Document

## Game Concept
A relaxing, VR "spot the object" game set in a Ghibli-esque sky world. Players recline and use binoculars to find specific objects among various airships, planes, skydivers, and other sky elements.

## Core Gameplay Elements

1. **Sky Environment**
- Vast, open sky with various moving objects
- Ghibli-inspired art style

2. **Player Interaction**
- Reclining position
- Binocular view with zoom functionality
- "Viewmaster" system for target images

3. **Sky Objects**
- Various types: airships, planes, skydivers, birds, etc.
- Randomized appearances and movements
- Some objects correspond to specific targets

4. **Companion NPC**
- Introduces game mechanics
- Provides ongoing commentary and hints
- Interacts through dialogue system

## Game Architecture

### 1. Main Scene
- Sky Environment
- Player Camera
- Object Spawner
- NPC
- UI Elements

### 2. Player System
- Camera control (subtle movements)
- Binocular view toggle
- Viewmaster image cycling
- Object detection (raycasting)
- NPC interaction trigger

### 3. Sky Object System
- Base Sky Object
- Shared properties: movement, visibility handling
- Specific object types (inheriting from base)
- Airship, Plane, Skydiver, Bird, etc.
- Randomization of object properties
- Colors, styles, logos, cargo, character features

### 4. Object Spawner
- Manages object lifecycle
- Ensures target objects are spawned
- Handles random object spawning
- Maintains object count and distribution

### 5. Viewmaster System
- Manages target images
- Switches between binocular view and target images
- Tracks current targets and matches

### 6. NPC and Dialogue System
- NPC Controller
- Manages NPC state and animations
- Triggers dialogue based on player interaction
- Dialogue Manager
- Handles dialogue flow and branching
- Manages response options
- Audio Manager
- Handles voice clip playback
- Manages audio interruptions and queuing
- Dialogue UI
- Displays text and dialogue options
- Handles player input for responses

### 7. Game State Manager
- Tracks player progress
- Manages scoring
- Handles game progression and difficulty

## Key Features

1. **Binocular Gameplay**
- Zoom and scan the sky
- Take "snapshots" to identify targets

2. **Viewmaster Target System**
- Cycle through target images
- Match viewed objects with targets

3. **Dynamic Sky Environment**
- Continuously moving and changing objects
- Mix of random and predetermined target objects

4. **Interactive NPC Companion**
- Context-sensitive dialogue
- Tutorial and hint system
- Adds personality to the game experience

5. **Progression System**
- Increasing difficulty with more complex or similar targets
- Score tracking and potential time pressure

## Technical Considerations

- Developed using Godot 4.2.2
- VR-focused design
- Efficient object management for performance
- Balancing randomness with deterministic target spawning
- Lip-sync system for NPC dialogue

## Art and Audio Requirements

- Ghibli-inspired sky and object designs
- Various sky object models and textures
- NPC character model and animations
- Voice acting for NPC dialogue
- Ambient sky sounds and music

## Next Steps

1. Prototype core mechanics (binocular view, object spawning)
2. Implement basic NPC and dialogue system
3. Develop initial set of sky objects
4. Create placeholder art and audio
5. Playtest and iterate on core gameplay loop

---

This document provides a high-level overview of the game's concept, core systems, and architecture. It should give team members a clear understanding of the game's structure without delving too deeply into programming specifics. The document can be expanded with more detailed sections on art direction, sound design, or specific gameplay scenarios as needed.

---

Here's a high-level project directory and scene structure that aligns with our game design:

/project_root
│
├── /scenes
│   ├── Main.tscn
│   ├── Player.tscn
│   ├── NPC.tscn
│   ├── UI.tscn
│   └── /sky_objects
│       ├── BaseSkyObject.tscn
│       ├── Airship.tscn
│       ├── Plane.tscn
│       ├── Skydiver.tscn
│       └── Bird.tscn
│
├── /scripts
│   ├── /autoload
│   │   ├── GameState.gd
│   │   ├── DialogueManager.gd
│   │   └── AudioManager.gd
│   ├── PlayerController.gd
│   ├── ObjectSpawner.gd
│   ├── ViewmasterSystem.gd
│   ├── NPCController.gd
│   ├── DialogueUI.gd
│   └── /sky_objects
│       ├── BaseSkyObject.gd
│       ├── Airship.gd
│       ├── Plane.gd
│       ├── Skydiver.gd
│       └── Bird.gd
│
├── /models
│   ├── /sky_objects
│   │   ├── airship.glb
│   │   ├── plane.glb
│   │   ├── skydiver.glb
│   │   └── bird.glb
│   └── npc_character.glb
│
├── /textures
│   ├── /sky_objects
│   │   ├── airship_atlas.png
│   │   ├── plane_atlas.png
│   │   ├── skydiver_atlas.png
│   │   └── bird_atlas.png
│   ├── /environment
│   │   ├── sky_texture.png
│   │   └── clouds_texture.png
│   └── /ui
│       ├── binocular_overlay.png
│       └── viewmaster_frame.png
│
├── /audio
│   ├── /music
│   │   └── ambient_sky_theme.ogg
│   ├── /sfx
│   │   ├── binocular_zoom.wav
│   │   └── snapshot.wav
│   └── /voice
│       ├── npc_intro_01.ogg
│       ├── npc_hint_01.ogg
│       └── npc_hint_02.ogg
│
└── /resources
    ├── /dialogue
    │   ├── introduction.tres
    │   └── hints.tres
    └── /target_images
        ├── target_airship_01.tres
        ├── target_plane_01.tres
        └── target_skydiver_01.tres

Scene Hierarchy Structure:

1. Main.tscn
- SkyEnvironment
- ObjectSpawner
- Player (instance of Player.tscn)
- NPC (instance of NPC.tscn)
- WorldUI (for any 3D user interface elements)
- CanvasLayer
- UI (instance of UI.tscn)

2. Player.tscn
- Camera3D
- BinocularModel (if visible in VR)
- RayCast3D (for object detection)

3. NPC.tscn
- NPCModel (MeshInstance3D)
- AnimationPlayer
- AudioStreamPlayer3D

4. UI.tscn
- ViewmasterOverlay
- DialoguePanel
- ScoreDisplay

5. BaseSkyObject.tscn
- MeshInstance3D
- AnimationPlayer (if needed)
- CollisionShape3D (if needed for detection)

6. Specific Sky Object scenes (Airship.tscn, Plane.tscn, etc.)
- Inherits from BaseSkyObject.tscn
- Adds or overrides specific components as needed

Key Points for Developers:

1. Use inheritance for sky objects, with BaseSkyObject as the parent class.
2. Implement the ObjectSpawner as a node in the Main scene, responsible for instancing and managing sky objects.
3. The ViewmasterSystem can be implemented as a standalone script, possibly attached to the Player scene.
4. Use autoload singletons (GameState, DialogueManager, AudioManager) for global access to game state and systems.
5. Keep the NPC as a separate scene for easy development and testing of dialogue features.
6. Organize resources (like dialogue data and target images) as Godot resources for easy management and loading.
7. Use a CanvasLayer in the Main scene for all 2D UI elements to ensure proper rendering in VR.

This structure provides a clear organization for the project, separating concerns and making it easy for different team members to work on specific components. The scene structure allows for modular development and testing of individual elements before integration into the main game.