HackerTrans
TopNewTrendsCommentsPastAskShowJobs

davidslv

no profile record

Submissions

Reverse-engineering Codemasters' BIGF archive format in Ruby

davidslv.uk
26 points·by davidslv·11 dagen geleden·5 comments

The Modular Monolith in Rails: Engines, Packwerk and Boundaries

davidslv.uk
3 points·by davidslv·17 dagen geleden·0 comments

When Rails Engines Are the Wrong Tool

davidslv.uk
3 points·by davidslv·20 dagen geleden·0 comments

Why Architecture Matters: Rails Engines for Modular Monoliths

davidslv.uk
4 points·by davidslv·2 maanden geleden·0 comments

Show HN: Terminal roguelike using Entity-Component-System in pure Ruby

github.com
4 points·by davidslv·8 maanden geleden·1 comments

Show HN: Vanilla Roguelike – My 5-Year Solo Ruby Project Now OSS

github.com
3 points·by davidslv·9 maanden geleden·0 comments

comments

davidslv
·11 dagen geleden·discuss
Author here. This started as a hobby attempt to understand Codemasters' old driving AI, which had received quite a few interesting game reviews at the time. Which meant first reading their "BIGF" archive format. The surprise was Ruby: String#unpack is basically a fast, C-backed binary parser hiding in the stdlib, and the whole reader is dependency-free. Repo (MIT): https://github.com/davidslv/bigf

Honest note: AI-assisted throughout — I steered and verified every claim against the bytes. No game data committed; tests synthesise fixtures from the documented format.
davidslv
·17 dagen geleden·discuss
[flagged]
davidslv
·20 dagen geleden·discuss
[dead]
davidslv
·8 maanden geleden·discuss
I spent 5 years building a roguelike game in pure Ruby (no game engines) to explore Entity-Component-System architecture and event-driven patterns outside of typical Rails applications.

Full disclosure: The project benefited significantly from AI assistance in the later stages to keep momentum going while balancing a full-time job and family. I used AI as a coding partner - I made all architectural decisions, reviewed every change, and stayed in control of the direction. It let me focus on the interesting problems (ECS design, event systems) rather than grinding through boilerplate.

The game runs entirely in the terminal and uses the same architectural patterns we use in production web apps - ECS for entity management, pub/sub for events, observer patterns for game state.

Why Ruby? Honestly, because it's the language I know best, and I wanted to prove you could build a game without reaching for Unity, Godot, or even a Ruby game library. It's all vanilla Ruby.

The codebase is fully open source and I've also written a book about the process (5 years in the making) that walks through the architecture decisions: https://www.amazon.com/Building-Your-Own-Roguelike-Hands-ebo...

Technical highlights:

- Entity-Component-System from scratch - Event-driven game loop - No dependencies (just Ruby stdlib) - Runs in the terminal

I'd love feedback from the HN community, especially on the architecture patterns. Happy to answer any questions about the implementation.

Thank you, davidslv