The next thing I've been tackling has been the verb/grammar code. The goal here is to represent the logic/data structures from this section of the #PunyInform library: https://github.com/johanberntsson/PunyInform/blob/master/lib/grammar.h#L7-L225
It looks like a combinatorial explosion of possible prepositions in a large space of possible sequences, along with placeholders for object search conditionals. It feels like the kind of thing that needs a lot of core just to map it all out. Sure, I have my input words compressed to single 12-bit integers, but there's a lot of repetition in the source there and it seems like a mess to represent.
I made a list of all the tokens in this thing, and came up with 32 values (including a null). Well, that's neat! I could decide that if the most significant bit of a tanner is `0`, it's a lookup into a table of 12-bit values. I have some space left in my compression scheme for ideas like "object in scope" or "object in inventory" (which can gobble multiple words), so I can handle common cases like `INVENTORY`, or `GET LAMP`, or `TURN ON LAMP`. I map the `TURN` verb into a pair of indices for `ON` and *noun*, pointing out to our equivalent of the Puny `SwitchOn` function in the #PDP8 game code.
Okay, but what about all that `'in'/'into'/'inside'/'on'/'onto'` stuff? Well, If the tanner's most significant bit is `1`, then I treat it as a sort of pointer into the second half of my grammar index. So that might look like this:
37. `IN`, `INTO`
38. `INSIDE`, *37*
39. `ON`, `ONTO`
40. *38*, *39*
So I might have `GET` mapping a grammar word of [*40*,*noun*] to the `ENTER` procedure, so that `GET INSIDE BICYCLE` and `GET ONTO BICYCLE` will both call the same code. The grammars use 3 words per mapping, and make use of a table of 64 words. This feels more comfortable for the type of system I'm writing here.
Yes, this is just #LISP cons cells, and I love that.
Now I just need to write all this...
https://massiverobot.itch.io/panic
I updated and really got it to the point for a release that isn't embarrassing. A small text adventure game (for Atari or any Z3 engine) that you can play and solve in 30min. Based on real events in Quakertown.
#punyinform #atari #infocom
The latest RetroAdventurers is out, in which we review `10 CAVE` Adventure, Young Arthur, and PunyJam #1 winner Captain Cutter's Treasure.
This was an older recording, so the sound quality may be a small step back from our current standards. We recorded it as a "buffer" back when we thought some light fare without news or mail might keep us going through a dry spell of recording, only to realise that we could double our recording schedule without trouble!
https://fed.brid.gy/r/https://bsky.app/profile/did:plc:bjpufa66d36itb5rzn3p6vrn/post/3lujfywb2zk2p #RetroComputing #InteractiveFiction #PunyInform
Episode 30 features two of the newest games we've covered although you'd hardly know it! Captain Cutter's Treasure (PunyInform), Young Arthur's Quest (VIC-20/C64), and 10 Cave Adventure (Sinclair ZX81) get a look. Also, Smooches Collier is in effect. retroadventurers.podbean.com/e/30/
After much testing and code comparison, the new Feb 2025 Release of #Vezza - my #z80 high speed #zmachine is ready! Took way longer than expected to synchronize across all of the code bases, particularly making sure that all optimizations made it across all platforms - TRS-80 model 1, TRS-80 model 3, TRS-80 model 4, the CP/M versions (~18 platforms), the embedded versions (Spectrum tape, TEC-1G), and slowly pushing into the Agon Light version (which has even more updates still in progress). Lots of individual tweaks, and some major rethinks and rewrites have come together to accelerate game play.
The hardest part of rewriting in this update involved rewriting the dictionary search code. I ended up going back to the original jzip interpreter, written in C for Unix waaay back when. Jzip provided much of the logic that went into ZXZVM, which provided the base for #M4ZVM #M3ZVM and #Vezza. Going back to Jzip made sense as Jzip has an even longer history; and is highly tested and stable and still maintained. This research gave me the confidence that the streamlining and changes I was making to such a fundamental part of the game would work, making all inputted dictionary searching more efficient.
To work around how CP/M stores executable files I spent a lot of time re-organising the memory map to make the executable smaller. This involved rearranging where the initialization code was stored inside the increasingly complex layout. Support across multiple versions means I needed to break up variable sized code and strings to sit inside variable sized gaps, while still compiling all the CP/M versions from the same interconnected set of source files. It needed quite a few manual checks to ensure that it all worked.
What this all means is that your favourite #infocom #punyinform and other text adventures will all play on your favourite z80 #retrocomputing platforms even faster than before!
More details in the devlog and downloads can be found at:
#TRS80 versions https://sijnstra.itch.io/m4zvm
#CPM #CPM80 versions https://sijnstra.itch.io/vezza
π₯οΈ β¨οΈ Some students and I, with a tremendous amount of advice, assistance, guidance, and wizardry from @spacehobo , have created an old-school text adventure to help teach about the importance of physical security in the context of cybersecurity. You can play it here:
https://lars.d.umn.edu/one_night_in_sf/
We really cannot thank @spacehobo enough for his ideas, help and contributions! π We could not have done it without him.
We'd love for you to test it out and send feedback to [email protected] or create issues at https://github.com/UMDLARS/one_night_in_sf/issues. #if #InteractiveFiction #security #inform #PunyInform
For assorted and dull reasons, I ended up with more of an Act I than an actual game for #buffalogamespace 9DJam.
Still, it was good practice at using #punyinform to write some #interactivefiction.
Space Hobo
andy diller
root42
Shawn Sijnstra
Petey P. Twelve
moosepod
caad