Large Codebases

What does the combat system architecture look like in this project?
Show me how player input flows through the codebase
Where is the save/load functionality implemented?

Trace how a player action becomes a game state change
Show me the path from @input_handler.gd to @game_state.gd
What happens when a player clicks the attack button?

What files depend on @player_manager.gd?
Show me all the systems that use @event_bus.gd
Which scripts are called by @level_loader.gd?

How is the inventory system organized in this project?

Looking at @inventory/inventory_manager.gd, how does item stacking work?

In @inventory/item.gd, modify the stack_size property to support different stack limits per item type

---
description: Combat System Patterns
---

1. All combat entities inherit from CombatEntity base class
2. Damage calculations use DamageCalculator.calculate_damage()
3. Status effects are managed through StatusEffectManager
4. Combat events are broadcast via CombatEventBus
5. Health changes trigger UI updates through HealthDisplay component

Create a new spell system similar to @abilities/melee_ability.gd
Follow the same pattern as @abilities/ranged_ability.gd for targeting
Use the cooldown system from @systems/cooldown_manager.gd
Integrate with the UI like @ui/ability_bar.gd does for other abilities

Refactor the entire combat system to support multiplayer

1. First, let's identify all the places where combat state is stored
2. Then we'll extract combat logic into a separate manager class
3. Next, we'll make the combat state serializable for network sync
4. Finally, we'll add network event broadcasting for combat actions

I need to add a crafting system to this RPG project.

Looking at @inventory/, @items/, and @ui/ folders, create a plan for:
- Where to place crafting-related scripts
- How to integrate with the existing inventory system
- What UI components we'll need
- How to store crafting recipes

Ask me questions if you need clarification about requirements.

I'm working on the player progression system in our RPG.
Architecture: @systems/progression/ contains all progression logic
Data flow: XP gains → @progression_manager.gd → @player_stats.gd → UI updates
Current issue: Level-up rewards aren't being applied correctly

Looking at @systems/combat/damage_calculator.gd and @entities/player.gd,
I need to add armor penetration mechanics that reduce damage mitigation

---
description: Singleton Manager Pattern
globs: "**/managers/*.gd"
---

1. All manager classes extend from BaseManager
2. Use @export var for configuration in editor
3. Initialize in _ready(), cleanup in _exit_tree()
4. Provide static get_instance() method
5. Emit signals for state changes, don't call other systems directly

Create a new HealthComponent following the pattern in @components/
- Inherits from BaseComponent like @components/movement_component.gd
- Provides health, max_health, and damage/heal methods
- Emits health_changed and death signals
- Can be attached to any entity that needs health

The inventory system should only:
- Manage item storage and retrieval
- Handle item stacking and splitting
- Emit inventory_changed signals

It should NOT:
- Update UI directly (that's the UI system's job)
- Handle item usage effects (that's the item system's job)
- Manage player stats (that's the stats system's job)

For this UI bug fix, only include context from @ui/ folder
Focus on @ui/inventory_panel.gd and related UI scripts
Don't load the entire combat system - it's not relevant here

Let's implement the quest system in phases:
Phase 1: Basic quest data structure and storage
Phase 2: Quest progress tracking
Phase 3: UI integration
Phase 4: Reward system integration

Start with Phase 1 - create the basic QuestData resource class

---
description: Team Coding Standards
---

1. Use PascalCase for class names, snake_case for variables
2. All public methods must have documentation comments
3. Use @export for designer-configurable values
4. Prefix private methods with underscore (_private_method)
5. Group related functionality in the same script file

Generate documentation for the @systems/combat/ folder
Include class descriptions, public method signatures, and usage examples
Format as markdown for our project wiki

I have a bug where player stats aren't saving correctly.

Let's trace the data flow:
1. Check @player/player_stats.gd - are stats being updated correctly?
2. Look at @systems/save_system.gd - is the save data being serialized?
3. Examine @data/save_data.gd - is the data structure correct?
4. Review @systems/file_manager.gd - are files being written to disk?

Create a simple test scene that only loads:
- @systems/inventory_manager.gd
- @data/item_database.gd
- Basic test items

This will help us isolate the inventory bug from other systems