Barrage - Bullet Patterns Whose Art Answers To The Pattern

Barrage is a bullet pattern system in which the choreography and the projectile art are the same object. A pattern is a pure function of (wave, shot, time). Ask it for a moment and it hands back every live shot with a position, a heading and a charge - and every one of those shots then draws itself from the pattern that fired it.

Raise the arm count and the gap between neighbouring shots narrows, so Barrage picks a narrower body. A ring of 12 fires fat round pellets; the same ring at 100 fires javelins, and the wall of fire stays readable instead of turning into a smear. That coupling is the product. The shelf sells the wiring and the art as separate things and never joins them - a fixed spritesheet draws the same bullet at every density, and at the top end it draws a solid wall.

What is in it

• 12 pattern families, each separated by what it asks the player to do: ring (move off the axis), fan (read the spread and pick a side), spiral, aimed, lace (find the moving gap), wall, rain, bloom, converge, whip, homing, arc.
• 45 projectile bodies across 8 silhouette classes, drawn in pure GML. No sprite, no spritesheet, no atlas - sprites/ does not exist in this package.
• 12 elements, each a five-stop ramp rather than a tint, so a body has an internal edge and survives being one of a hundred overlapping shapes.
• Every shot drawn rotated to its own heading. That single property is what a spritesheet cannot do without 360 frames per body per palette.

It measures whether the player can actually see it

An unreadable bullet is a death the player could not have avoided. Barrage measures crowding (sampled across the radii a wave really occupies, because a ring is most crowded when it is young), contrast against your field's lightness band at rest and fully charged, and warning time. It reports the number, the floor it failed against, and the knob that moves it - and it reports rather than clamps, because a pattern too dense to read is a design decision you should be told about rather than have made for you.

Scrubbing is free

Because a pattern is a pure function of time, running it backwards is the same operation as running it forwards. Preview a wave, crawl to the exact frame a shot stops being readable, or count the live shots at t=1.75 - without a clock running and without spawning a single instance.

spec  = bar_pattern_spec(BAR_PAT_RING, 24, 5, 11, 360, 0.30, 0, 0.34, 0, 0);
body  = bar_bullet_for(spec.arms, 0.9, "pellet", 0.055);
var _live = bar_pattern_live(spec, t);
for (var _i = 0; _i < array_length(_live); _i++) {
    var _s = _live[_i];
    bar_render_parts(bar_bullet_parts(body, _s.charge),
                     bar_element_pal(elem, _s.charge),
                     x + _s.x * _unit, y + _s.y * _unit,
                     _unit * 0.055, _s.heading, 1, undefined);
}

Compatibility

• GameMaker 2024.14+, legacy runtime. Built and gated against 2024.14.4.268. Nothing here needs a GMRT-only feature.
• No shaders, no extensions, no sprites. The drawing path is draw_primitive, draw_circle and draw_line_width, so it works anywhere GameMaker draws - including onto your own surface or inside a GUI event.
• No collision, no instances, no objects required. bar_pattern_live is a function; you decide what holds the result. Hit detection against your player is yours, and the kill radius is published so you can write it in one line.
• 162 functions and 63 macros, every one bar_ / BAR_ prefixed, and three globals, all namespaced. Nothing here can collide with a name in your project.
• Deterministic. Jitter is seeded from each shot's own identity, never from random(), so scrubbing is stable and two calls for the same shot return the same shot.

What it is not

It is not a bullet-hell engine - there is no player, no scoring, no enemy AI and no collision system. It is not a sprite pack. The look is the product's own: flat masses with a drawn relief pass, lit from one fixed lamp.

Verify it yourself

The package ships its own test suite and the renderer that made this page's images, and both are things you can run. Barrage.exe -selftest writes 2,293 assertions to your local app data; Barrage.exe -bake re-renders every sheet above. The GIF and the in-use screenshot were drawn by the demo room's own draw code, so the claim that the pictures on this page were made by the code you are buying is one you can check.

Import the .yymps, open rm_bar_demo, press Play. Left/right walks the twelve families, up/down walks the twelve elements, Q/E scrubs the clock.

AI disclosure: this package's code and its generated artwork were written with AI assistance. It contains no audio and no narrative text. The cover is a generated illustration; every other image on this page was rendered by the product itself.

Also from CSAF, for GameMaker

Beacon — energy and beams is the beam to this one's bullet: Beacon renders lightning, lasers, chains and tethers from primitives, Barrage renders the projectiles a pattern fires.

Raiment — characters and clothing · Pastime — minigames · Liege — the NPC day · Charter — auto-cartography · Verdure — cultivation · Effigy — NPC portraits · Hearth — interiors · Shoal — fishing