C64 Assembly

Twenty-nine chapters, from the first byte to the complete game

1. 01The machine behind the blue screen

   A practical map of the computer you are about to control.

2. 02Assemble, load, debug

   Turn readable source into a repeatable C64 program.

3. 03Registers, flags, addresses

   Make every operand and branch a deliberate choice.

4. 04Arithmetic, bits, loops

   Turn bytes into counters, positions, masks and repeatable work.

5. 05Stack, subroutines, interfaces

   Build routines that can call, return, cooperate and grow.

6. 06Interrupts, raster, frame timing

   Let hardware choose the moment without surrendering control.

7. 07Pointers, tables, data structures

   Turn raw bytes into collections a game can reason about.

8. 08Modules, state machines, dispatch

   Divide one game into contracts that can grow without losing control.

9. 09Screen memory, characters, display modes

   Turn addresses, patterns and color nibbles into a game world the VIC-II can display.

10. 10Hardware sprites, animation, collisions

    Give the game independent actors, timed motion and collision rules the hardware cannot invent for you.

11. 11Scrolling, raster splits, moving worlds

    Move the camera without letting memory ownership, timing or the HUD drift with it.

12. 12Sprite multiplexing, culling, slot schedules

    Turn eight physical channels into a deterministic display service for a crowded game world.

13. 13SID voices, waveforms, envelopes, sound services

    Turn game events into owned, timed and testable sound without scattering SID writes through the codebase.

14. 14Music drivers, patterns, tempo

    Turn note data into a portable three-voice performance with explicit timing, ownership and room for game effects.

15. 15Game loops, input, entity state

    Turn frame tokens and control snapshots into a coherent world that updates, collides, sounds and renders deterministically.

16. 16Level data, rooms, progression

    Turn authored maps into validated, persistent and transactionally loaded game spaces.

17. 17Enemy behavior and AI

    Build opponents that sense, decide and act predictably inside a fixed frame budget.

18. 18Projectiles, weapons and combat

    Turn fire intent into bounded projectiles, deterministic hits and readable consequences.

19. 19HUD, score, lives and game flow

    Turn committed gameplay into a readable, complete play session.

20. 20Menus, options and persistence

    Build the recoverable front end around a finished play session.

21. 21Profiling and frame budgets

    Measure first; optimize only the frame that needs it.

22. 22Fixed-point and lookup tables

    Keep the fraction; publish only the precision the screen needs.

23. 23Object pools and spatial partitions

    Bound the population; spend exact work only on plausible contacts.

24. 24Memory layout, overlays and bank-aware assets

    Give every byte an owner, a lifetime and a visible publication point.

25. 25Multi-load assets and scene transactions

    Load privately, prove the bytes, publish once.

26. 26Compression and safe decompression

    Pack on the host, bound every byte, publish only proof.

27. 27Fastloaders and compatibility boundaries

    Accelerate the transport; preserve the contract.

28. 28Cartridges and release qualification

    Map the ROM, test the candidate, archive the proof.

29. 29Final Fortress: the complete game

    Integrate the contracts. Survive the wave. Return cleanly.