>
> The Visible Zorker is super nifty! I totally see what you mean about the
> language being Lispy. Did people program directly in it or was it just a
> p-code target for game generator programs? I'm looking forward to exploring
> it more and seeing if it will let me modify and execute code on the fly,
> but first I better play through Zork 2; I've never tried it before and it
> is clear these twisty passages are full of spoilers.
>

It was a pcode engine for the game code written in the lisp type stuff.
There's a totally non lisp game compiler for it as well (inform) that was
written independently.

The Zork language (ZIL) comes from MDL which actually was a lisp and is
similar to DDL and ADL from UCLA.

https://archive.org/details/Learning_ZIL_Steven_Eric_Meretzky_1995/

is an internal manual written mostly after the fact but by the original
people.


>  For The Quill a search for Gilsoft Quill will find you the original
>> manuals which gives a good flavour of how the table driven systems worked.
>>
>
> Following your advice, I immediately got lost in a rabbit-hole that I
> —having been raised on the wrong side of the pond — didn't even
> know existed. I knew nothing of the text adventure scene in Europe. Thanks
> for the tip on "table driven
> <https://archive.org/details/practical-computing/PracticalComputing-1980-08/page/68/mode/1up>"
> systems; that helped me to understand better what is happening under the
> hood. Am I understanding correctly that Scott Adams invented that idea? I
> mean, sure humans
>

Scott certainly invented it. Did anyone else parallel invent it before him
- I don't know. The published pirate and adventureland in BASIC were hugely
influential in everything table based that followed.

Some people used the same system as was but wrote their own implementation
- eg the Brian Howarth Mysterious Adventures others riffed off the same
theme.


> Even more than the technology, I enjoyed learning about the creativity
> and community <https://www.filfre.net/2013/07/the-quill/> that blossomed
> in Europe in the early 80's with tools like The Quill. What a thing for
> people to one day realize they have the power to create worlds that others
> could journey into. While I'm aware of a few isolated niches in the States,
> I think we lacked the critical mass of community for anything comparable
> until the 1990s when we finally caught on to MUDs (Multi-User Dungeons).
>

It's really odd because these things did exist in the USA they just never
caught on in the way that they did in Europe. There were several systems
for the Trash 80 and other machines but none of them ever caught on or
became more than obscure footnotes.

The original Essex MUD (late 1970s) actually does use table driven stuff
for part but not all of the game engine, and has a separate game builder.
That's also around these days as the BCPL and DEC10 asm code was released.

https://github.com/PDP-10/MUD1

and see files like VALLEY.TXT which is a small subgame and you'll see the
table stuff.

AberMUD didn't use tables as it kind of congealed rather than got designed.
It would have been an awful lot smaller in code/data size if I had done so
from the start. AberMUD 5 did use tables (and became the game engine for
games like Elvira and Simon the Sorceror in the 16bit era).

The really amusing bit of the story to me is that when the Quill engine
became too limiting and before they released the later PAWS system several
games were produced using a from scratch written sort of "Quill and a bit"
by Roger Taylor that ran on a BBC Micro and floppy disk drive. That in turn
actually ended up in Adventure International UK and was used for some of
the later conversions of the Scott Adams products to other things as well
as a couple of gems like Kayleth.

So Scott led to Quill which led to Roger's system which was used to port
layer Scott stuff 8)

It appears Radio-Shack never released Pirate's Adventure, or any
> interactive fiction, for the Model 100 but that snippet of the BASIC
> version from Byte would run almost unchanged. I'll have to take a look at
> the data file format, but if it's not too crazy, it should be possible to
> port. According to IFArchive
> <https://www.ifarchive.org/indexes/if-archive/games/trs80/>, a handful of
> text adventures were written for the Model 100 .
>

 The data format is pretty simple. There are also tools that will spit it
out in other formats - for several ports for example I've got tools that
spit out C versions of it, and 6803 assembler versions (for the Tandy MC10).

Lots of other stuff was table/script based including all the classic Sierra
games (Kings Quest etc).

Alan

Reply via email to