BYTEPATH++ Attacks and Seeker

#401Jul 13, 2026  22:38Legacy transcriptFable 5
Speaker and timing data unavailable
Ctrl + F

Summary

Built out BYTEPATH++'s combat slice: the four attacks (normal/shotgun/dart/pulse), a full sound pass with the F3 sound-tuner port, a codebase-modernization sweep onto Anchor framework systems, the seven-enemy .rogue roster port — then the session's two biggest decisions: that roster was removed as "forced" in favor of a single SNKRX-style seeker horde enemy, and (post-seal addendum) the expedition-map design arrived — THE TOWER: phase 1 became a vertical ascent whose stacked bands persist and become the descent, with destruction seeding the descent's difficulty. design.md fully revised.

Transcript

Let's start with BYTEPATH++. Let's implement 4 attacks, one for each major type. Which ones do you think they would be?

I'll read the BYTEPATH++ design doc first to ground this in what's already settled.

ReadE:\a327ex\BYTEPATH++\design.md
Input
E:\a327ex\BYTEPATH++\design.md
Output
1	# BYTEPATH++ — Design — Expeditions / Forge / Descent
2	
3	Written 2026-07-11. Name locked: **BYTEPATH++** (all caps). Lore-free by decision —
4	the game stands on gameplay alone; any lore (BYTEPATH-universe or otherwise) gets
5	figured out later. The previously developed Technochrist worldbuilding is shelved at
6	`E:/a327ex/private/technochrist-game-lore.md` and is NOT assumed anywhere below.
7	Design lineage: BYTEPATH (visual style + big tree + name), BYTEPATH.rogue (combat +
8	CRT shaders + rosters), Roguelite Design Analysis 2 (structure lessons — Summit/B-Side
9	phase purity, Tab's use-or-bank tension, Heirloom's restraint economy, and the
10	commitment-weight thesis: "a decision the player must live with is the cheapest drama
11	a roguelite can buy, and the market barely stocks it").
12	
13	---
14	
15	## Design pillars
16	
17	1. **Commitment over optionality.** The game trains follow-through, never rerolling.
18	   No respec, no rollback, no null choices. The two phases sit at opposite ends of the
19	   commitment-weight axis (phase 1 light per-decision, phase 2 locked/critical) and
20	   crossing between them is the game's central event.
21	2. **Anti-idler, hard rules:** no wall-clock or offline progression of any kind; a
22	   defined ending; bounded NG+ (no infinite prestige); exactly one AFK-capable build
23	   archetype, and only as an earned endgame expression (a deep tree keystone).
24	3. **Meaningful actions.** Moment-to-moment play must contain real decisions:
25	   route scarcity (you can never take everything), readable-but-learnable world
26	   (knowledge = mastery), and execution that stays load-bearing (dodge-centric,
27	   low-HP combat). No vacuum-simulator scavenging, no number-goes-up-for-free.
28	4. **Ends properly.** One arc = expeditions → forge → descent → ending. The game is
29	   proud to end.
30	
... [200 more lines]
ReadD:\2020-2021 code\old\BYTEPATH.rogue\todo
Input
D:\2020-2021 code\old\BYTEPATH.rogue\todo
Output
1	300 level variants
2	modules window
3	sounds
4	trailer + steam page
5	
6	*Seeker 100 - 1000
7	*Shooter 150 - 1500
8	*Block 200 - 2000
9	*Exploder 200 - 2000
10	*Gyro 400 - 4000
11	*Barrager 400 - 4000
12	*Host 900 - 9000
13	*Shotgunner 200 - 2000
14	*Orbitter 200 - 2000
15	*Spawner 800 - 8000
16	*Moving Bar 1000 - 10000
17	*Enemy Area
18	
19	*Normal 
20	*Shotgun - 12 fast moving but decelerating projectiles shot at the same time, high cooldown
21	*Cannon - high damage and high cooldown single projectile
22	*Dart - damage over time projectile, normal cooldown
23	*Shield - area damage over time that increases with each shot and decreases the bigger it is, reaching an equilibrium
24	*Spread - many low damage projectiles shot at random angles, low cooldown
25	*Triple - three projectiles shot at the same time, normal cooldown
26	*Pulse - high area damage, high cooldown
27	*Mines - mines that explode when near enemies, high area damage, high mine production cooldown
28	
29	*Pierce - pierces through enemy, +10% damage per pierce
30	*Finale - every 4th projectile deals double damage
... [62 more lines]
Bashls "E:/a327ex/BYTEPATH++"
Input
ls "E:/a327ex/BYTEPATH++"
Output
anchor/
assets/
design.md
main.lua
reference/
run.bat
tuner_export.txt
Bashwc -l "E:/a327ex/BYTEPATH++/main.lua"; ls "E:/a327ex/BYTEPATH++/reference"
Input
wc -l "E:/a327ex/BYTEPATH++/main.lua"; ls "E:/a327ex/BYTEPATH++/reference"
Output
1258 E:/a327ex/BYTEPATH++/main.lua
archetypes.md
source-catalogs.md
ReadE:\a327ex\BYTEPATH++\main.lua
Input
E:\a327ex\BYTEPATH++\main.lua
Output
1	--[[
2	  BYTEPATH++ — first playable slice.
3	
4	  Player moves as the mouse cursor and fires the pulse attack (the area attack)
5	  against a static block enemy that takes damage and dies. All juice is a
6	  faithful port of BYTEPATH.rogue (D:/2020-2021 code/old/BYTEPATH.rogue,
7	  main.moon + common.moon) — per-event effects, timings, and constants are
8	  copied from source, with line references noted throughout. Names are
9	  translated from the old PascalCase convention to snake_case.
10	
11	  Render pipeline (main.moon L125-220): game world at 480x270 -> displacement
12	  shader pass (UV warp from a displacement map fed by ambient/death glitch
13	  blocks) -> nearest 3x upscale -> CRT shader (playscii framebuffer_f_crt) at
14	  window resolution -> flash overlay.
15	
16	  Deliberate deviations from the original, per owner instruction:
17	  - the block enemy is stationary (original patrols horizontally)
18	  - no sounds (verified: the original has none; its todo lists sounds as
19	    unfinished)
20	  - player death just refills hp (arena/run flow is future work)
21	  - skipped: mod-list HUD, cycle-timer HUD bar, constructs (inactive or
22	    absent in this slice)
23	]]
24	
25	require('anchor')({
26	    width = 480,
27	    height = 270,
28	    title = 'BYTEPATH++',
29	    scale = 3,
30	    filter = 'rough',
... [1229 more lines]

The pulse attack (the area type) is already in the slice. Before answering, let me check the two reference docs — archetypes.md sounds like it might already define the major types.

ReadE:\a327ex\BYTEPATH++\reference\archetypes.md
Input
E:\a327ex\BYTEPATH++\reference\archetypes.md
Output
1	# Archetype Analysis — what BYTEPATH++ builds from its two parents
2	
3	Written 2026-07-11, from reference/source-catalogs.md. Purpose: extract the
4	recurring archetypes across BYTEPATH.rogue (2020) and BYTEPATH (2018), judge them
5	against BYTEPATH++'s design (design.md: expeditions/forge/descent, finite tree,
6	anchor keystones, one AFK archetype, commitment pillars), and propose the build
7	roster. PROPOSALS ONLY — owner picks. ⭐ = recommended for v1 combat.
8	
9	────────────────────────────────────────────────────────────────────────────────
10	## 1. Attack shapes (union of 9 + 17 attacks → 13 shapes)
11	────────────────────────────────────────────────────────────────────────────────
12	
13	| Shape | .rogue | BYTEPATH | Note |
14	|---|---|---|---|
15	| ⭐ single | normal | Neutral/Rapid | baseline; Rapid = the aspd variant |
16	| ⭐ heavy single | cannon | (2x dmg node builds) | slow big hit |
17	| ⭐ cone burst | shotgun | Blast | 12-shot decelerating wave |
18	| ⭐ fast scatter | spread | Spread/Rapid | dps hose, low aim demand |
19	| multi-parallel | (double mod) | Double/Triple | more of the same shot |
20	| ⭐ radial | pulse | Spin (rotating) | the area statement; pulse is ours already |
21	| ⭐ attached DoT | dart | — | .rogue-unique; pairs with the DoT stat line |
22	| ⭐ aura | shield | — | .rogue-unique; the shots-grow-a-field idea is special |
23	| ⭐ mines/zoning | mines | (drop_mines proc) | placed threat |
24	| homing | — | Homing | aim-forgiveness; tension with cursor skill thesis |
25	| chain | — | Lightning | auto-target adjacency; same tension as homing |
26	| on-hit split | (fork mod) | 2Split/4Split | .rogue treats it as a modifier — better |
27	| beam | — | Laser | expensive to build well; strong identity though |
28	| stream | — | Flame | ammo-hungry hose; distinct feel |
29	| directional cover | (back mod) | Back/Side | .rogue treats it as a modifier — better |
30	| wall-bounce | (ricochet mod) | Bounce | modifier in .rogue — better |
... [147 more lines]
ReadE:\a327ex\BYTEPATH++\reference\source-catalogs.md
Input
E:\a327ex\BYTEPATH++\reference\source-catalogs.md
Output
1	# Source Catalogs — BYTEPATH.rogue (2020) & BYTEPATH (2018)
2	
3	Compiled 2026-07-11, verified against source (not design notes/todos).
4	Sources: `D:/2020-2021 code/old/BYTEPATH.rogue/` (main.moon + common.moon) and
5	`D:/2020-2021 code/old/BYTEPATH/` (the shipped-game copy — objects/Player.lua 2396
6	lines; the `2017-2018 code` copies are earlier snapshots).
7	
8	═══════════════════════════════════════════════════════════════════════════════
9	# PART 1 — BYTEPATH.rogue (2020)
10	═══════════════════════════════════════════════════════════════════════════════
11	
12	Cursor-is-the-ship arena shooter with a fake-OS meta shell. One player entity, no
13	characters/classes. Combat = attack (1 equipped) × passives (drafted) × enemies.
14	
15	## Attacks (9) — one equipped; auto-fire while LMB held; RMB flips facing
16	
17	| Attack | CD | Color | Behavior (shoot, main.moon L1633+) |
18	|---|---|---|---|
19	| normal | 0.2 | white | single projectile, 250 speed |
20	| shotgun | 0.8 | red | 12 projectiles, 400-800 speed, ±30° cone, decelerate & die |
21	| cannon | 0.4 | red | single 350-speed projectile, 2x damage, trail |
22	| dart | 0.3 | green | projectile attaches a DoT dart (per-enemy stack ticks every 0.5s) |
23	| shield | 0.35 | green | no projectile: shots grow a square aura (+5 target, decays to
24	| | | | equilibrium); aura AoE-ticks enemies every 0.25s for 25 |
25	| spread | 0.08 | yellow | 1 projectile ±15° random, 0.75x damage, very fast fire |
26	| triple | 0.16 | yellow | 3 projectiles −15°/0°/+15°, 0.5x damage (desc says 60°, code 15°) |
27	| pulse | 0.8 | blue | 8 radial decelerating projectiles 0.5x + bracket effect + 100x100
28	| | | | area hit at 50 + flash + shake |
29	| mines | 0.8 | blue | slow 4x4 spinning mine, decelerates 1.6-3.2s |
30	
... [176 more lines]

Good timing for this question — the archetypes doc already sorted the 9 .rogue attacks into shape families, and pulse (the area statement) is already implemented in the slice. So the question is really: which 4 of the remaining 8 attacks best cover the remaining major delivery types?

Here's how the 9 .rogue attacks group into types:

TypeAttacks in itStatus
Radial area burstpulse✅ done
Direct projectilenormal, cannon—
Volume fire (multi-projectile)shotgun, spread, triple—
Damage over timedart—
Aura (area-over-time, no projectile)shield—
Placed/zoningmines—

That's five open types for four slots, so one gets cut. My pick:

  1. Normal — direct projectile. The baseline everything else is measured against, and the canvas the 20 projectile modifiers will read clearest on. Cheapest of all: the projectile class already exists; this mostly adds aimed fire along attack_r (the RMB facing flip is already wired). Cannon is the same delivery type with different numbers, so it doesn't earn a type slot.
  2. Shotgun — volume fire. The most mechanically distinct of the trio: 12 projectiles, 400–800 speed, ±30° cone, decelerate-and-die — and the decelerating-projectile path already exists (pulse_decel is exactly that mechanic, just with random angles). Spread and triple are just fire-rate/count variations on normal, so shotgun is the one that represents the family.
  3. Dart — DoT. This is the slot that pays infrastructure dividends: it forces the DoT subsystem into existence (attached dart entity, per-enemy stacks, 0.5s tick), which the entire dot stat family plus decay/amplify/contagion/decaying_shot all depend on later. Without a DoT attack, one of the five stat lines has nothing to attach to.
  4. Mines — placed/zoning. The only attack that lives in the world independent of your aim, which makes it feel like a genuinely different verb rather than a projectile variant. It exercises proximity-trigger + area explosion (reusing get_enemies_in_area and the pulse effect vocabulary), and it's the foundation the minefield on-kill/on-cycle procs will stand on.

The cut is shield, and I'd argue for it consciously: the archetypes doc already flags the aura as its own subsystem ("the shots-grow-a-field idea is special"), and it's the most bespoke of the eight — a persistent growing/decaying field with equilibrium math and its own tick loop shares almost nothing with the projectile pipeline. It deserves its own pass rather than being the fourth item in a batch. Dart covers the "damage over time" axis in the meantime.

One alternative worth naming: cannon instead of normal, if you'd rather each attack feel maximally distinct (heavy slow hit vs the shotgun's wave vs dart vs mines). But I think normal earns its slot precisely by being the neutral reference — you want it in the game early so every other attack and every modifier has something to be compared against.

If this roster looks right, my next step is a design brief for the four (dart's DoT subsystem and mines' lifecycle are the two parts with actual design decisions in them — the other two are mostly parameter variations on existing code).

We already have area, let's do normal, shotgun and dart.

Right — normal, shotgun, and dart it is. Let me read the exact source behavior in BYTEPATH.rogue before writing the design brief, since the port is supposed to be faithful.

Grepshotgun|dart|Dart
Input
shotgun|dart|Dart
Output
551:    when "shotgunner"
1174:    @darts = {}
1182:    if #@darts > 0
1187:        for dart in *@darts
1188:          dmg += dart.damage
1490:        if @attack == "shotgun"
1543:          attacks = {"normal", "shotgun", "cannon", "dart", "shield", "spread", "triple", "pulse", "mines"}
1570:            attacks = {"normal", "shotgun", "cannon", "dart", "shield", "spread", "triple", "pulse", "mines"}
1651:    mods = {damage_multiplier: @damage_multiplier, pierce: @pierce, finale: (@finale_counter == 5), ricochet: @ricochet, fork: @fork, spawn: @spawn, dart: (@attack == "dart"), pulse: (@attack == "pulse"), mines: (@attack == "mines"), explosion: @explosion, scatter: @scatter, telekinesis: @telekinesis, nova_spawn: @nova_spawn, decaying_shot: @decaying_shot, spark: @spark}
1669:      when "shotgun"
1671:        mods.shotgun_decel = true
1696:      when "dart"
1803:      when "shotgun"
1809:      when "dart"
2078:          table.insert projectiles, EnemyProjectile(@x + @w*cos(@r), @y + @w*sin(@r), rng\float(250, 400)*remap(@mm, 1, 10, 1, 2), @r + rng\float(-pi/8, pi/8), red, {shotgun_decel: true})
2802:    if @mods.shotgun_decel
3095:      if @mods.dart
3096:        table.insert pre_effects, Dart(@x, @y, @r, @w, @h, @color, @damage, other)
3099:      if not @mods.dart
3144:class Dart
3147:    table.insert @parent.darts, @
3171:    if @mods.shotgun_decel
ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
1630	          when "autocannon"
1631	            g.setColor red
1632	        g.rectangle "fill", c.x - 3, c.y - 3, 6, 6
1633	
1634	  shoot: =>
1635	    if @attack == "spread"
1636	      @sx, @sy = 1.2, 1.2
1637	      @timer\tween 0.1, @, {sx: 1, sy: 1}, linear, (-> @sx, @sy = 1, 1)
1638	      table.insert effects, ShootEffect(@x + @attack_m*@w/2, @y, 0, @color, @, 6)
1639	      table.insert effects, RectangleParticle(@x + @attack_m*@w/2, @y, rng\float(50, 200), @attack_r + rng\float(-math.pi/4, math.pi/4))
1640	    else
1641	      @sx, @sy = 1.5, 1.5
1642	      @timer\tween 0.1, @, {sx: 1, sy: 1}, linear, (-> @sx, @sy = 1, 1)
1643	      table.insert effects, ShootEffect(@x + @attack_m*@w/2, @y, 0, @color, @)
1644	      for i = 1, 4 do table.insert effects, RectangleParticle(@x + @attack_m*@w/2, @y, rng\float(50, 200), @attack_r + rng\float(-math.pi/4, math.pi/4))
1645	
1646	    if @finale then @finale_counter += 1
1647	    if @nova then @nova_counter += 1
1648	    if @barrage then @barrage_counter += 1
1649	    if @supershot then @supershot_counter += 1
1650	
1651	    mods = {damage_multiplier: @damage_multiplier, pierce: @pierce, finale: (@finale_counter == 5), ricochet: @ricochet, fork: @fork, spawn: @spawn, dart: (@attack == "dart"), pulse: (@attack == "pulse"), mines: (@attack == "mines"), explosion: @explosion, scatter: @scatter, telekinesis: @telekinesis, nova_spawn: @nova_spawn, decaying_shot: @decaying_shot, spark: @spark}
1652	
1653	    if @supershot_counter >= 8
1654	      @supershot_counter = 0
1655	      mods.supershot = true
1656	
1657	    switch @attack
1658	      when "normal"
1659	        if @double
... [170 more lines]

Now the Dart entity, the projectile's dart/shotgun_decel handling, and the enemy-side dart stack logic:

ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
3080	      g.setColor white
3081	
3082	  on_collision_enter: (other, contact) =>
3083	    if other.__class == Block or other.__class == Shooter or other.__class == Exploder or other.__class == Barrager or other.__class == Gyro or other.__class == Host or other.__class == HostOrbitter or other.__class == Seeker or other.__class == MovingBar or other.__class == Shotgunner or other.__class == Spawner or other.__class == Orbitter
3084	      if any(@enemies_hit, other.id) then return
3085	
3086	      if @mods.pierce then @damage *= 1.1
3087	      if @mods.fork
3088	        mods = copy @mods
3089	        mods.fork = false
3090	        timer\after 0.01, (->
3091	          table.insert projectiles, Projectile(other.x, other.y, @v, @r - math.pi/4, @color, mods, {other.id})
3092	          table.insert projectiles, Projectile(other.x, other.y, @v, @r + math.pi/4, @color, mods, {other.id})
3093	          table.insert effects, ProjectileHitEffect(other.x, other.y, nil, @color, other)
3094	        )
3095	      if @mods.dart
3096	        table.insert pre_effects, Dart(@x, @y, @r, @w, @h, @color, @damage, other)
3097	        other\light_hit!
3098	      if not @mods.pierce then @dead = true
3099	      if not @mods.dart
3100	        other\hit @damage, @
3101	        table.insert effects, ProjectileHitEffect(@x, @y, nil, (other and other.target_color) or red, other)
3102	      if @mods.explosion
3103	        camera\shake 1, 0.2
3104	        table.insert effects, ExplosionEffect(@x, @y, 20*player.area_multiplier)
3105	        for enemy in *get_enemies_in_area(@x, @y, 50*player.area_multiplier, 50*player.area_multiplier)
3106	          enemy\hit 0.5*@damage, @
3107	          if player.area then timer\every 0.25*player.dot_multiplier, (-> enemy\hit 0.5*@damage/5, @), 5
3108	      if @mods.decaying_shot
3109	        table.insert effects, DecayArea(@x, @y, 20*player.area_multiplier)
... [85 more lines]
ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
1165	      g.setColor white[1], white[2], white[3], 0.1
1166	      g.rectangle "fill", @x - 5, @y - 2, @w + 10, @h + 4
1167	    g.setColor white
1168	    @info_text\draw!
1169	
1170	class Collider
1171	  new: =>
1172	    @id = rng\uid!
1173	    @sx, @sy = 1, 1
1174	    @darts = {}
1175	    @dot_timer = 0
1176	    @dot_cd = 0.5
1177	
1178	  update: (dt) =>
1179	    if @body
1180	      @x, @y = @body\getPosition!
1181	
1182	    if #@darts > 0
1183	      @dot_timer += dt
1184	      if @dot_timer > @dot_cd*player.dot_multiplier
1185	        @dot_timer = 0
1186	        dmg = 0
1187	        for dart in *@darts
1188	          dmg += dart.damage
1189	        @\hit dmg
1190	
1191	  draw: =>
1192	    if @body
1193	      switch @shape
1194	        when "rectangle"
... [10 more lines]

A few more details — light_hit, pre_effects, and the projectile's shotgun_decel branch:

Greplight_hit|pre_effects
Input
light_hit|pre_effects
Output
134:  pre_effects = {}
168:  update_objects pre_effects, dt
186:  draw_objects pre_effects
1249:  light_hit: =>
3096:        table.insert pre_effects, Dart(@x, @y, @r, @w, @h, @color, @damage, other)
3097:        other\light_hit!
ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
2764	class Projectile extends Collider
2765	  new: (@x, @y, @v, @r, @color=white, @mods, @enemies_hit={}) =>
2766	    super!
2767	    @timer = Timer!
2768	
2769	    @damage = 25*(@mods.damage_multiplier or 1)
2770	    if @mods.finale then @damage *= 2
2771	    if @mods.ricochet then @ricochet_amount = 2
2772	    if @mods.scatter then @scatter_amount = @mods.scatter_amount or 3
2773	    if @mods.spawn
2774	      if @mods.mines
2775	        @timer\every rng\float(0.5, 1), (->
2776	          mods = copy @mods
2777	          mods.damage_multiplier = 0.5*@mods.damage_multiplier
2778	          mods.spawn = false
2779	          table.insert effects, ProjectileHitEffect(@x, @y, nil, @color)
2780	          table.insert projectiles, Projectile(@x, @y, @v, @r - math.pi/2, @color, mods)
2781	          table.insert projectiles, Projectile(@x, @y, @v, @r + math.pi/2, @color, mods)
2782	        ), 3
2783	      else
2784	        @timer\every rng\float(0.5, 1), (->
2785	          mods = copy @mods
2786	          mods.damage_multiplier = 0.5*@mods.damage_multiplier
2787	          mods.spawn = false
2788	          table.insert effects, ProjectileHitEffect(@x, @y, nil, @color)
2789	          table.insert projectiles, Projectile(@x, @y, @v, @r - math.pi/2, @color, mods)
2790	          table.insert projectiles, Projectile(@x, @y, @v, @r + math.pi/2, @color, mods)
2791	        )
2792	
2793	    if @mods.mines then @\set_rectangle 4, 4
... [30 more lines]
ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
1243	  destroy: =>
1244	    if @body
1245	      @fixture\destroy!
1246	      @body\destroy!
1247	      @fixture, @body = nil, nil
1248	
1249	  light_hit: =>
1250	    @sx, @sy = 1.15, 1.15
1251	    @hit_flash = true
1252	    @timer\tween 0.1, @, {sx: 1, sy: 1}, linear, (->
1253	      @sx, @sy = 1, 1
1254	      @hit_flash = false
1255	    ), "hit"
1256	
1257	  hit: (damage, projectile) =>
1258	    if @dead then return
1259	
1260	    if @__class == MovingBar
1261	      @sx, @sy = 1.05, 1.05
1262	    else
1263	      @sx, @sy = 1.35, 1.35
1264	    @hit_flash = true
1265	    @timer\tween 0.1, @, {sx: 1, sy: 1}, linear, (->
1266	      @sx, @sy = 1, 1
1267	      @hit_flash = false
1268	    ), "hit"
1269	
1270	    @hp -= damage
1271	    if @hp <= 0
1272	      @dead = true

One last check — where pre_effects sits in the draw order:

ReadD:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Input
D:\2020-2021 code\old\BYTEPATH.rogue\main.moon
Output
160	
161	update = (dt) ->
162	  aesthetic\send "time", time
163	  world\update dt
164	  update_objects displacements, dt
165	  update_objects players, dt
166	  update_objects projectiles, dt
167	  update_objects enemies, dt
168	  update_objects pre_effects, dt
169	  update_objects effects, dt
170	  update_objects post_effects, dt
171	  update_objects ui, dt
172	  update_objects ui_effects, dt
173	
174	draw = ->
175	  g.setCanvas displacement_canvas
176	  g.clear!
177	  g.setColor 0.5, 0.5, 0.5, 1
178	  g.rectangle "fill", 0, 0, gw, gh
179	  draw_objects displacements
180	  g.setCanvas!
181	
182	  g.setCanvas game_canvas
183	  g.clear!
184	  g.setColor white
185	  camera\attach!
186	  draw_objects pre_effects
187	  draw_objects projectiles
188	  draw_objects enemies
189	  draw_objects effects
... [10 more lines]

I've got everything I need from the source. Here's the design brief.

🔒 Only the summary of this log is public. Private because this is BYTEPATH++.

Settings