PluginBench
Skill
Pass
Audit score 90

godot-gdscript-patterns

wshobson/agents

Master Godot 4 GDScript patterns: signals, scenes, state machines, and optimization for game development.

What is godot-gdscript-patterns?

A reference for production-ready GDScript patterns in Godot 4.x, covering architecture, signals, scene design, state management, and performance optimization. Use this when building games, implementing game systems, or learning Godot best practices.

  • Learn Godot architecture fundamentals including nodes, scenes, resources, signals, and groups
  • Understand GDScript syntax with exports, onready variables, and private variable conventions
  • Implement signal-based event communication between game objects
  • Design scene hierarchies and reusable node trees
  • Manage game state with state machines and event patterns
  • Optimize GDScript performance for production games

How to install godot-gdscript-patterns

npx skills add https://github.com/wshobson/agents --skill godot-gdscript-patterns
Prerequisites
  • Godot 4.x installed
  • Basic understanding of game development concepts
  • Familiarity with GDScript syntax (or similar programming language)
Claude Code
Cursor
Windsurf
Cline

How to use godot-gdscript-patterns

  1. 1.Review the core concepts section to understand Godot's node, scene, signal, and resource architecture
  2. 2.Study the GDScript basics example to learn export variables, onready initialization, and signal patterns
  3. 3.Reference the detailed pattern documentation in references/details.md for advanced patterns and worked examples
  4. 4.Apply patterns to your game systems: implement signals for event communication, use exports for inspector tuning, and follow naming conventions
  5. 5.Consult the skill when designing scene hierarchies, managing state, or optimizing performance

Use cases

Good for
  • Building a player character system with health, damage, and attack mechanics
  • Implementing event-driven communication between game systems using signals
  • Designing reusable scene components for enemies, UI, or interactive objects
  • Creating state machines for game states (menu, playing, paused, game over)
  • Structuring game architecture to follow Godot best practices and conventions
Who it's for
  • Godot game developers
  • GDScript programmers
  • Game designers implementing systems in Godot 4
  • Developers learning Godot architecture and patterns

godot-gdscript-patterns FAQ

What Godot version does this cover?

This skill covers Godot 4.x and GDScript patterns specific to that version.

Do I need prior Godot experience to use this?

Basic familiarity with game development and GDScript syntax is helpful, but the skill covers fundamentals like nodes, scenes, and signals.

Where is the detailed pattern documentation?

Detailed patterns and worked examples are in the references/details.md file included with the skill.

What topics are covered beyond the basics shown?

The skill covers state machines, optimization techniques, and advanced architectural patterns referenced in the detailed documentation.

Full instructions (SKILL.md)

Source of truth, from wshobson/agents.


name: godot-gdscript-patterns description: Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization. Use when building Godot games, implementing game systems, or learning GDScript best practices.

Godot GDScript Patterns

Production patterns for Godot 4.x game development with GDScript, covering architecture, signals, scenes, and optimization.

When to Use This Skill

  • Building games with Godot 4
  • Implementing game systems in GDScript
  • Designing scene architecture
  • Managing game state
  • Optimizing GDScript performance
  • Learning Godot best practices

Core Concepts

1. Godot Architecture

Node: Base building block
├── Scene: Reusable node tree (saved as .tscn)
├── Resource: Data container (saved as .tres)
├── Signal: Event communication
└── Group: Node categorization

2. GDScript Basics

class_name Player
extends CharacterBody2D

# Signals
signal health_changed(new_health: int)
signal died

# Exports (Inspector-editable)
@export var speed: float = 200.0
@export var max_health: int = 100
@export_range(0, 1) var damage_reduction: float = 0.0
@export_group("Combat")
@export var attack_damage: int = 10
@export var attack_cooldown: float = 0.5

# Onready (initialized when ready)
@onready var sprite: Sprite2D = $Sprite2D
@onready var animation: AnimationPlayer = $AnimationPlayer
@onready var hitbox: Area2D = $Hitbox

# Private variables (convention: underscore prefix)
var _health: int
var _can_attack: bool = true

func _ready() -> void:
    _health = max_health

func _physics_process(delta: float) -> void:
    var direction := Input.get_vector("left", "right", "up", "down")
    velocity = direction * speed
    move_and_slide()

func take_damage(amount: int) -> void:
    var actual_damage := int(amount * (1.0 - damage_reduction))
    _health = max(_health - actual_damage, 0)
    health_changed.emit(_health)

    if _health <= 0:
        died.emit()

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.