Beacon — Procedural Energy Renderer for GameMaker

A sprite sheet cannot connect two things that move. The moment a bolt has to start at a wand and end at whichever enemy is currently closest, pre-rendered lightning has to stretch to an arbitrary length and rotate to an arbitrary angle — and stretched lightning reads as stretched lightning. Chain arcs that jump between four live targets, a leash that sags between two moving instances, a trail that follows an actual flight path: none of them have a fixed length or a fixed angle, so none of them can be a fixed image.

Beacon generates the light instead, in pure GML. Lightning, beams, lasers, chains, tethers and motion trails are built as geometry every frame from a handful of primitives — no atlas to re-export, no resolution to outgrow, and a colourway you change by assigning a struct field.

Six verbs, one system

bolt · beam · laser · chain · tether · trail

This is the part that makes it a system rather than six snippets: every effect compiles to the same intermediate — a BeaconPath — and one renderer draws them all. Retune the renderer and every effect in your game changes together. Write a new generator that emits a BeaconPath and it inherits the entire look for free.

Layered additive light, not a coloured line

Each path draws in three passes as triangle-strip ribbons: a wide faint halo, a saturated glow, and a thin near-white core. The three widths sum into a falloff the eye reads as energy — which is the whole difference between a lightning effect and a debug polyline. Beams carry travelling pulses and an aperture bloom at the emitter; the demo's holy pillar lands an impact flare where it meets geometry.

Four authored colourways ship — Arc (electric blue-white), Plasma (magenta-violet), Holy (gold-white) and Void (toxic green) — and every number in them is a plain struct field, so retuning is direct rather than a setter API to learn.

Deterministic on purpose

There is no random() anywhere in Beacon. Every spark comes from a 32-bit hash of (seed, node, time-bucket). Two runs are byte-identical, which means captures reproduce, replays stay in sync, and lockstep multiplayer cannot desync on cosmetics — a real failure mode for anyone who has tried to add screen-shake-grade VFX to a deterministic build.

It also buys the look: a bolt holds one shape for its hold window and then re-rolls, so lightning flickers on a cadence instead of boiling every frame. Displacement is bounded by a geometric series, so arcs jitter without ever wandering off toward the corner of the room.

Tethers sag by equation

A leash is a closed-form parabola with a sway term — no verlet chain, no physics step, no accumulated state to explode after an alt-tab. Attach it to two instances and it tracks them for as long as they both live. If one is destroyed the effect simply stops drawing; chain targets are dropped one at a time the same way, so an arc through four enemies keeps working as they die.

Built to be read

• Pure GML. No native extension, no DLL, no dependency — nothing to break on a runtime update.
• The generators are engine-free. beacon_core takes coordinates, a time in milliseconds and a config struct, and returns a path. No engine calls at all, so the half that can be wrong is the half you can read.
• Blend state is saved and restored around every draw, including the _ext form. A renderer that leaks bm_add into your pipeline is a support ticket you cannot debug remotely; nothing you draw afterwards washes out.
• One conversion, one place. delta_time is microseconds and Beacon's clocks are milliseconds — the single conversion lives on one commented line.
• Namespaced. Everything is beacon_ / __beacon_. GML's global namespace is flat; nothing here collides with your project.
• A runnable 5-page demo room ships beside the library, so you can evaluate every claim on this page in two minutes.

The API, in three lines

fx = beacon_fx_create("bolt", beacon_pt(100, 100),
                      beacon_anchor(obj_enemy), beacon_preset_arc());
beacon_fx_tick(fx);   // Step
beacon_fx_draw(fx);   // Draw

Endpoints are fixed points or live instances, mixed freely. A chain reads its route from fx.targets; a trail follows its own endpoint's history.

What's in the download

• Beacon.yymps — import via Tools › Import Local Package
• The full raw project — readable, commented source, no minification
• 4 scripts (the generators zero-engine-call), the demo object, the demo room, 2 fonts
• Readme with quickstart, the full API, and limits stated plainly

Built and verified on the stable GameMaker 2024.x runtime. GMRT is not a dependency and is not claimed. 2D only — Beacon draws the light between two points; damage, targeting and cooldowns stay yours.

More GameMaker systems from CSAF

• Loom — secondary animation: cloth, hair and tails that follow your sprites automatically.
• Pliant — sprite mesh deformation: squash, stretch and bend without redrawing a frame.
• Meridian — procedural skill trees, drawn as constellations from 60 authored motifs.
• Trove — procedural item icons and a full inventory model.
• Kinetic UI — spring-animated menus, HUDs and interface motion.

All pure GML, all raw commented source, all built by the same two-person studio.