Index of every page on this site: llms.txt
All skills
jame581 avatar

/csharp-signals

@426e8ab
by Jan Mesarčjame581/godotprompter979 stars
63
Run it yourself

Use when implementing signals in C# — [Signal] delegates, EmitSignal patterns, and async signal awaiting. Triggers on declaring, emitting, connecting, or awaiting a signal from a C# script, and on a signal crossing between C# and GDScript in either direction.

Use this Skill: https://skilld.dev/gh/jame581/godotprompter/csharp-signals

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈69 tokens for metadata: the name and description. ≈2.6k when used: this file. ≈3.2k more on demand in 4 files.

Description uses 3.5% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈276 characters, or 3.5%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Signals in C# (Godot 4.x)

This skill is C# only. For general C# conventions and project setup, see the csharp-godot skill. Godot signals in C# require a different mental model from GDScript: delegates declared with [Signal], strongly-typed +=/-= connections, and mandatory disconnection in _ExitTree(). All examples target Godot 4.x with no deprecated APIs.

Related skills: csharp-godot for C# conventions and project setup, event-bus for global signal hub architecture, component-system for signal-based component communication.


1. Signal Declaration

Signals are declared as public delegate void with the [Signal] attribute inside a partial class that extends a Godot type. The delegate name must end with EventHandler — Godot strips that suffix to produce the signal name exposed to the engine.

using Godot;

public partial class Player : CharacterBody2D
{
    // Signal name in engine: "HealthChanged"
    [Signal] public delegate void HealthChangedEventHandler(int current, int maximum);

    // Signal name in engine: "Died"
    [Signal] public delegate void DiedEventHandler();

    // Signal name in engine: "ItemCollected"
    [Signal] public delegate void ItemCollectedEventHandler(string itemName);
}

Naming rules:

Delegate name Engine signal name
HealthChangedEventHandler HealthChanged
DiedEventHandler Died
ItemCollectedEventHandler ItemCollected
PlayerSpawnedEventHandler PlayerSpawned

Omitting the EventHandler suffix is a compile error: the source generator reports GD0201, "The name of the delegate must end with 'EventHandler'".

Parameter type constraints: Signal parameters must be Variant-compatible: numeric types, bool, string, enums, Godot structs (Vector2, Color, …), StringName, NodePath, GodotObject subclasses, Godot.Collections.Array/Dictionary (including the generic Array<T>/Dictionary<TKey, TValue>) and packed-array equivalents such as int[]. Other C# classes and structs fail the build with GD0202.


2. Emitting Signals

Use EmitSignal(SignalName.SignalName, args...). The SignalName nested class is auto-generated by the Godot source generators at build time — one cached StringName per declared signal.

using Godot;

public partial class Player : CharacterBody2D
{
    [Signal] public delegate void HealthChangedEventHandler(int current, int maximum);
    [Signal] public delegate void DiedEventHandler();
    [Signal] public delegate void ItemCollectedEventHandler(string itemName);

    [Export] public int MaxHealth { get; set; } = 100;
    private int _currentHealth;

    public override void _Ready()
    {
        _currentHealth = MaxHealth;
    }

    public void TakeDamage(int amount)
    {
        _currentHealth = Mathf.Clamp(_currentHealth - amount, 0, MaxHealth);

        // Type-safe emission — SignalName.HealthChanged is a generated constant.
        EmitSignal(SignalName.HealthChanged, _currentHealth, MaxHealth);

        if (_currentHealth == 0)
            EmitSignal(SignalName.Died);
    }

    public void CollectItem(string itemName)
    {
        EmitSignal(SignalName.ItemCollected, itemName);
    }
}

EmitSignal does not check its arguments against the delegate. With the wrong argument count, += handlers on a custom [Signal] are skipped without an error, and Connect/GDScript receivers log Error calling from signal … Method expected N argument(s), but called with M. With a wrong type, C# handlers get the value converted or defaulted (0, null); a typed GDScript receiver logs Cannot convert argument N from X to Y and is not called.


3. Connecting Signals

The += operator (preferred)

using Godot;

public partial class HudLayer : CanvasLayer
{
    private Player _player;

    public override void _Ready()
    {
        _player = GetNode<Player>("../Player");

        // Connect with += — mirrors C# event syntax.
        _player.HealthChanged += OnHealthChanged;
        _player.Died          += OnDied;
        _player.ItemCollected += OnItemCollected;
    }

    private void OnHealthChanged(int current, int maximum)
    {
        GetNode<ProgressBar>("HealthBar").Value = (double)current / maximum * 100.0;
        GetNode<Label>("HealthLabel").Text = $"{current} / {maximum}";
    }

    private void OnDied()
    {
        GetNode<Control>("DeathScreen").Show();
    }

    private void OnItemCollected(string itemName)
    {
        GetNode<Label>("PickupLabel").Text = $"Picked up: {itemName}";
    }
}

Lambda connections

Use lambdas for one-off, short-lived responses. Store the lambda in a field if you need to disconnect it later.

// Anonymous lambda — cannot be disconnected by reference later.
_player.Died += () => GetNode<AudioStreamPlayer>("DeathSound").Play();

// Stored lambda — can be disconnected.
private Action<string> _onItemCollected;

public override void _Ready()
{
    _onItemCollected = (itemName) =>
    {
        _collectCount++;
        UpdateCollectDisplay();
    };
    _player.ItemCollected += _onItemCollected;
}

public override void _ExitTree()
{
    _player.ItemCollected -= _onItemCollected;
}

Connecting in _Ready()

Connect inside _Ready() — or _EnterTree() for a node that is removed and re-added, since _Ready() runs only once. The node's references are resolved and the scene tree is available at that point. Connecting in the constructor or field initializers may fail because Godot node infrastructure is not yet initialised.


4. Disconnecting Signals

When a GodotObject is freed, Godot disconnects its connections, for emitters and receivers alike. Two cases are not cleaned up when the receiver is freed while the emitter lives on: a += on a custom [Signal], and a lambda that captures a variable. In both, the next emission reaches a disposed object and throws ObjectDisposedException, so disconnect with -= yourself in _ExitTree(). For a node that can leave and re-enter the tree, connect in _EnterTree() instead of _Ready(), which runs only once.

See references/disconnecting.md for the -= cleanup pattern, the two cases Godot does not clean up, and a SafeDisconnect helper.


5. Awaiting Signals

await ToSignal(node, SignalName.X) pauses until the signal fires. Returns Variant[] of the signal's args. Add a timeout with Task.WhenAny or a CancellationTokenSource to avoid permanent hangs.

See references/awaiting-signals.md for basic await, return-value extraction, and both timeout patterns.


6. Custom Signal Patterns

Three patterns: typed event args (wrap signal payload in a Resource subclass), static event bus (use C# static event as a pure-C# alternative when both peers are C#), generic signal helper (one helper per SignalName.X to reduce repetition).

See references/custom-signal-patterns.md for full code on each pattern.


7. Connecting GDScript Signals from C#

When the signal is declared in a GDScript node and the listener is C#, use node.Connect("signal_name", new Callable(this, MethodName.Handler)). The MethodName generated symbol still works for C# methods.

See references/connecting-gdscript-signals.md for the full pattern with both string-name and MethodName variants.


8. Common Mistakes

Mistake Symptom Fix
Forgetting EventHandler suffix on the delegate Build fails with GD0201: the delegate name must end with 'EventHandler' Rename to XxxEventHandler
Wrong parameter types in EmitSignal C# handlers: no error, the value is converted or defaulted (0, null); typed GDScript receivers: Cannot convert argument N from X to Y, handler not called Match EmitSignal args exactly to the delegate signature
Connecting to a freed object ObjectDisposedException or silent crash on next signal emission Guard with IsInstanceValid before connecting; store reference safely
Not disconnecting a custom [Signal] or a capturing lambda ObjectDisposedException on the next emission after the receiver is freed; built-in signals with a method handler are cleaned up automatically Add a matching -= in _ExitTree() (or Dispose()) for those two cases
Passing wrong argument count to EmitSignal += handlers silently not called; Connected receivers log "Method expected N argument(s), but called with M" Count signal delegate parameters and match exactly
Using static C# events for cross-language signals GDScript cannot observe the event; no error, just silent non-delivery Use Godot [Signal] for any signal GDScript must receive
Double-connecting the same handler On a custom [Signal] the handler fires twice per emission; on a built-in signal the second += logs "already connected" Check if already connected, or use ConnectFlags.OneShot; never call += twice for the same method
Awaiting a signal in _Ready() before the tree is ready NullReferenceException or signal never resolves because the source node is not yet in the tree Defer with await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame) first, or move the await to a method called after _Ready()

9. Checklist

  • Every [Signal] delegate name ends with EventHandler
  • EmitSignal uses SignalName.XxxName constants (not raw strings)
  • EmitSignal argument count and types match the delegate signature exactly
  • All += connections are in _Ready() (not in constructors or field initializers)
  • Every += on a custom [Signal], and every capturing lambda, has a matching -=
  • IsInstanceValid guards are in place where the signal source may be freed before the subscriber
  • Lambdas stored in fields if disconnection is needed later
  • async signal awaits are not blocking _Ready() directly; deferred if necessary
  • Cross-language signals (GDScript emitter, C# subscriber) use Connect("snake_case_name", Callable.From<T>(Method))
  • Static C# events used only for pure-C# communication paths
  • RefCounted-derived wrapper classes used for complex signal payloads, not plain C# classes or structs

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts7d3 checks · Risk SAFE
  • Gen Agent Trust Hub7d

    The skill provides safe documentation and code templates for implementing Godot 4.x signals in C#. No malicious patterns, obfuscation, or data exfiltration risks were detected.

  • Socket7d

    No alerts

  • Snyk7d

    Risk: LOW · No issues

Signed by skilld at 426e8ab. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 6 days ago.

Activeupdated last week

README badge

README badge for jame581/godotprompter/csharp-signals