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.

  • Explains Godot architecture fundamentals including nodes, scenes, resources, signals, and groups
  • Demonstrates GDScript syntax and conventions including exports, onready bindings, and private variables
  • Covers signal-based event communication for decoupled game systems
  • Provides patterns for scene organization and reusable node trees
  • Includes optimization techniques for GDScript performance
  • Documents state machine patterns for managing game state

How to install godot-gdscript-patterns

npx skills add https://github.com/wshobson/agents --skill godot-gdscript-patterns
Claude Code
Cursor
Windsurf
Cline

How to use godot-gdscript-patterns

  1. 1.Review the core concepts section to understand Godot's node, scene, and signal architecture
  2. 2.Study the GDScript basics example to learn syntax conventions like @export, @onready, and signal declarations
  3. 3.Consult references/details.md for in-depth pattern documentation beyond the overview
  4. 4.Apply signal patterns to decouple game systems and manage event communication
  5. 5.Implement scene-based architecture for reusable, composable game objects
  6. 6.Reference optimization patterns when profiling identifies performance bottlenecks

Use cases

Good for
  • Building a player character controller with health, damage, and animation systems
  • Implementing event-driven communication between game systems using signals
  • Designing scene hierarchies for complex game levels or UI
  • Creating reusable prefab-like scenes with configurable exports
  • Optimizing performance-critical game loops and physics calculations
Who it's for
  • Game developers using Godot 4
  • GDScript programmers new to Godot patterns
  • Game architects designing system interactions
  • Developers optimizing Godot game performance
  • Teams establishing Godot coding standards

godot-gdscript-patterns FAQ

What Godot version does this cover?

Godot 4.x with GDScript 2.0 syntax and features.

Does this include state machine patterns?

Yes, state machine patterns are covered in the detailed documentation in references/details.md.

Can I use these patterns in existing Godot projects?

Yes, these are production patterns applicable to any Godot 4 project; adopt them incrementally as needed.

Are there performance optimization techniques included?

Yes, GDScript performance optimization patterns are documented in the skill.

Where is the detailed pattern documentation?

Comprehensive pattern details are in the references/details.md file included with the skill.

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.