Pulse

Let your game speak in signals (and stop hand-wiring everything).

Want damage events to update your health bar, play a sound, trigger screen shake, and annoy the save system... without you personally introducing every one of those systems like it's a forced networking event?

Pulse is a signals and events framework for GameMaker. Your game broadcasts what happened, and anything that cares can react - without the sender needing to know who is listening.

Join the RefresherTowel Games Discord

---

Why you need Pulse

Because at some point in every GameMaker project, you end up writing the same sentence 400 times:

"Ok, when X happens, also tell Y... and Z... and the thing I forgot about... and the UI... and the sound... and the particles... and the save system... and..."

Pulse is how you stop doing that.

Your game can just say what happened

Instead of manually calling five different scripts, you do this:

• "Player took damage."
• "Enemy died."
• "Quest updated."
• "Door unlocked."

Then everything that cares can react on its own. No awkward hand-wiring. No "who owns this responsibility?" existential crisis.

Stuff stops being glued together

Pulse is basically a decoupling machine.

• The player does not need to know your UI exists.
• Your UI does not need a direct reference to the player.
• Your VFX system can be swapped, removed, or rewritten without touching gameplay code.

It is the difference between "my project is a web of spaghetti" and "my project is a bunch of polite little modules that mind their own business."

It starts simple, and stays simple

Beginners: you can live happily with just two calls:

• Subscribe to a signal.
• Send a signal.

That is it. You do not need to learn the fancy stuff on day one.

Your game can talk back

Sometimes you do not want to shout "something happened".
Sometimes you want to ask "ok... who knows the answer to this?"
Pulse can do that too.

When your project gets bigger, Pulse already has the grown-up tools

This is the part where experts start nodding and beginners go "ohhh, that is why my last project hurt."

Pulse gives you escape hatches for all the nasty real-world problems:

• Query signals: ask a question ("who wants to handle this?") and collect answers, instead of inventing a new bespoke manager every time.
  
• Priorities: so the important listener runs first.
• Consumable signals: so one listener can say "cool, I handled this" and stop the rest.
• Sender filters: so you can listen to "damage" from that enemy, not every enemy.
• Queued dispatch: post events now, flush them later when it is safe.
• Subscription groups: bind a pile of listeners to a state/room/UI panel and clean them up in one go.
• Multiple buses: keep gameplay events, UI events, and debug events from stepping on each other.

It is harder to shoot yourself in the foot

Pulse tries to stay out of your way, but it also tries to keep things tidy:

• Works with instances and structs.
• Uses weak references and prunes dead listeners.
• Gives you result enums so you can actually tell what happened (instead of guessing).

Your code becomes easier to read

Pulse nudges you toward code that sounds like a story:

• "When the player takes damage, update the health bar."
• "When an enemy dies, drop loot."
• "When a quest completes, play a stinger and show the banner."

Not:

• "Ok so obj_player calls obj_ui_manager which calls scr_update_health which calls..."

If you want a tiny, lightweight signal system, Pulse does that. If you want an event layer that can carry a whole game without collapsing into chaos, Pulse does that too.

---

What Pulse does

Instead of directly calling every system yourself:

// Somewhere in gameplay code:
PulseSend(SIG_DAMAGE_TAKEN, { amount: 10 }, id);

You let systems subscribe and react independently:

// UI:
PulseSubscribe(obj_hud, SIG_DAMAGE_TAKEN, function(_data) {
    hp_bar_target = hp_bar_target - _data.amount;
});
// Audio:
PulseSubscribe(obj_audio, SIG_DAMAGE_TAKEN, function(_data) {
    audio_play_sound(snd_hit, 0, false);
});
// VFX:
PulseSubscribe(obj_vfx, SIG_DAMAGE_TAKEN, function(_data) {
    fx_screen_shake(4);
});

Same event. Multiple listeners. No hard references. No "who calls who" mess.

---

Key features

• Persistent and one-shot listeners (subscribe forever, or subscribe once and auto-remove).
• Priority ordered dispatch so important listeners run first.
• Consumable signals so one listener can cancel the rest when appropriate.
• Sender filters (listen to this signal only when it came from that sender).
• Queued dispatch (post now, flush later) for safer timing.
• Query signals (broadcast a question, collect responses) for "pick a handler" and "gather offers" style problems.
• Listener builder API when you want tags, priorities, once, sender filters, and custom buses without a pile of parameters.
• Subscription groups to clean up a whole bundle of listeners in one call.
• Introspection tools for debugging: counts, dumps, and per-signal inspection.
• Multiple independent buses via PulseController, if you want strict isolation (UI vs gameplay vs debug, etc).
• Safety features: weak refs, pruning of dead listeners, and result enums for error checking.

---

Included in the download

• Pulse script library for GameMaker (GML 2.3+).
• Example usage showing basic setup and common patterns.
• A link to the full online documentation.
• A free copy of Echo - a debugging logger manager.

---

Requirements

• GameMaker 2.3 or later (GML with structs and methods).

---

Support and feedback

If you run into issues or have ideas for improvements:

• Discord (questions, discussion, show and tell): https://discord.gg/acAqBcYHgV

---

Part of the RefresherTowel Games frameworks

Pulse is part of a growing suite of GameMaker frameworks that are designed to play nicely together. If you like this style of tooling, you might also want:

• Statement - a state machine framework (with a fully visual in-game debugger).
• Echo - advanced debug logging (level filtering, tags, optional stack traces, history dumps).

I have been dogfooding these tools across my own projects for a long time, and I hope they make your codebase calmer, cleaner, and harder to accidentally sabotage at 2am.