# Asreonn Godot Superpowers Godot Extract Resources

> Extract Data to Resources

- Skill: `tomevault-io/asreonn-godot-superpowers-godot-extract-resources` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add tomevault-io/asreonn-godot-superpowers-godot-extract-resources`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/asreonn-godot-superpowers-godot-extract-resources/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tomevault-io (https://skillmd.com/u/tomevault-io)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tomevault-io/asreonn-godot-superpowers-godot-extract-resources

---


# Extract Data to Resources

## Core Principle

**Data belongs in resources, not code.** Hardcoded values make iteration slow and error-prone.

## What This Skill Does

Finds patterns like:
```gdscript
# enemy.gd
const ENEMY_DATA = {
    "goblin": {"health": 50, "speed": 100, "damage": 10},
    "orc": {"health": 100, "speed": 80, "damage": 20},
    "dragon": {"health": 500, "speed": 150, "damage": 50}
}
```

Transforms to:
```gdscript
# enemy_stats.gd
class_name EnemyStats
extends Resource

@export var enemy_name: String
@export var health: int
@export var speed: float
@export var damage: int
```

Creates resource files:
- `resources/enemies/goblin.tres`
- `resources/enemies/orc.tres`
- `resources/enemies/dragon.tres`

Updates code:
```gdscript
# enemy.gd
@export var stats: EnemyStats

func _ready():
    health = stats.health
    speed = stats.speed
    damage = stats.damage
```

## Detection Patterns

Identifies:
- `const` arrays with data structures
- Dictionaries with game data
- Embedded configuration values
- Hardcoded stats, properties, settings
- Switch statements on type strings

## When to Use

### You're Building Data-Heavy Games
Games with many items, enemies, levels, or configurations.

### You're Iterating on Balance
Want to tweak values quickly without code changes.

### You're Working with Designers
Non-programmers need to edit game data.

### You're Adding Moddability
External data files enable modding support.

## Process

1. **Scan** - Find const arrays, dictionaries with structured data
2. **Analyze** - Identify data schema and relationships
3. **Define** - Create Resource class definitions
4. **Extract** - Generate .tres files with data
5. **Update** - Modify code to load resources
6. **Validate** - Ensure data loads correctly
7. **Commit** - Git commit per resource type

## Example Transformation

**Before (Hardcoded Data):**
```gdscript
# item_manager.gd
const ITEMS = [
    {
        "id": "health_potion",
        "name": "Health Potion",
        "description": "Restores 50 HP",
        "heal_amount": 50,
        "icon": "res://icons/potion.png"
    },
    {
        "id": "sword",
        "name": "Iron Sword",
        "description": "A basic sword",
        "damage": 15,
        "icon": "res://icons/sword.png"
    }
]

func get_item(id: String):
    for item in ITEMS:
        if item.id == id:
            return item
    return null
```

**After (Resource-Based):**
```gdscript
# item_data.gd
class_name ItemData
extends Resource

@export var id: String
@export var item_name: String
@export_multiline var description: String
@export var icon: Texture2D
@export_group("Stats")
@export var heal_amount: int
@export var damage: int
```

```gdscript
# item_manager.gd
@export var items: Array[ItemData]

func get_item(id: String) -> ItemData:
    for item in items:
        if item.id == id:
            return item
    return null
```

**Created Files:**
- `resources/items/health_potion.tres`
- `resources/items/iron_sword.tres`

## Resource Patterns

### Simple Resources
Single values (stats, settings, constants).

### Composite Resources
Resources referencing other resources (weapon + stats + effects).

### Resource Libraries
Arrays of resources for different categories.

### Resource Inheritance
Base resource class with specialized variants.

## What Gets Created

- Resource class definitions in `resources/` or `scripts/resources/`
- .tres files in organized directory structure
- Updated code using @export var resource: ResourceType
- Documentation of resource schema
- Git commits per resource extraction

## Smart Analysis

**Identifies data types:**
- **Configuration** - Settings, constants, tuning values
- **Content** - Items, enemies, levels, abilities
- **Behavior** - AI patterns, state machines, rules

**Organizes by category:**
- `resources/items/` - Item data
- `resources/enemies/` - Enemy stats
- `resources/levels/` - Level configurations
- `resources/abilities/` - Ability definitions

## Integration

Works with:
- **godot-extract-to-scenes** - Scenes reference resources
- **godot-split-scripts** - Resources reduce script size
- **godot-refactor** (orchestrator) - Runs as part of full refactoring

## Safety

- Data preserved exactly during extraction
- Validation ensures resources load correctly
- Rollback on validation failure
- Original data preserved in git history

## When NOT to Use

Don't extract if:
- Data is truly constant (math constants, engine limits)
- Data changes at runtime (calculated values)
- Data is temporary state (not configuration)
- Extraction makes code more complex

Examples of valid hardcoded data:
- `const PI = 3.14159`
- `const MAX_PLAYERS = 4` (engine limitation)
- Calculated values based on other data

## Resource Organization

```
resources/
├── items/
│   ├── consumables/
│   │   ├── health_potion.tres
│   │   └── mana_potion.tres
│   └── weapons/
│       ├── iron_sword.tres
│       └── steel_axe.tres
├── enemies/
│   ├── goblin.tres
│   ├── orc.tres
│   └── dragon.tres
└── levels/
    ├── level_1.tres
    └── level_2.tres
```

## Benefits

- **Rapid iteration** - Change data without recompiling
- **Designer-friendly** - Edit values in Godot inspector
- **Type safety** - @export provides validation and autocomplete
- **Moddability** - External .tres files can be modified
- **Version control** - Data changes tracked separately from code
- **Hot reload** - Godot reloads resource changes automatically

## Common Transformations

| Before (Hardcoded) | After (Resource) |
|-------------------|------------------|
| `const STATS = {...}` | `@export var stats: Stats` |
| `var data = ITEMS[0]` | `var data = preload("item.tres")` |
| `if type == "fire":` | `if ability.element == Element.FIRE:` |
| `const CONFIG = {...}` | `@export var config: GameConfig` |

## Resource Types

### Built-in Resources
- Texture2D, Material, AudioStream
- Animation, Curve, Gradient
- Theme, StyleBox, Font

### Custom Resources
- EnemyStats, ItemData, LevelConfig
- AbilityDefinition, QuestData
- Any game-specific data structure

### Resource Collections
- Array[ItemData] for item databases
- Dictionary for lookup tables
- Resource library scenes

---
> Converted and distributed by [TomeVault](https://tomevault.io/claim/asreonn) — claim your Tome and manage your conversions.
<!-- tomevault:4.0:skill_md:2026-04-13 -->

