What are your IF Hot Takes and Unpopular Opinions?

General Off-Topic Discussion
127

So I don’t have an ELI5 tutorial, but here would be my elevator pitch. Here’s some code from Familiar Problems; the goal is to determine which rooms have currently solvable puzzles in them (that is, puzzles you can solve with your current abilities and inventory, without needing anything else), in order to highlight them on the minimap.

First, we want to determine whether a particular puzzle depends on another.

($Child depends on $Parent)
	*($Child requires $Parent)
($Child depends on $Parent)
	*($Child requires $Intermediate)
	($Intermediate depends on $Parent)

We define that $Child depends on $Parent if $Child requires $Parent, or, if $Child requires $Intermediate, and $Intermediate depends on $Parent. Note the recursive definition here—almost everything in Dialog is recursive in one way or another.

Also note that it’s not a problem that we never specify what $Intermediate will be. We don’t have to explicitly loop over all the options; all that matters is that there exists some $Intermediate that makes all these queries succeed.

($Puzzle is missing dependencies)
	*($Puzzle depends on $Other)
	~(solved $Other)

We say $Puzzle is missing dependencies if it depends on some $Other, and $Other is not solved. Again, we don’t have to explicitly specify what $Other is; Dialog will take care of figuring out if there exists any $Other that will make these queries succeed.

And now, in our game code, we can just specify:

(puzzle #glasscase)
(solved #glasscase)
	(#glasscase is open)
(#glasscase requires #f-resonate)

The glass case is a puzzle, it’s solved if it is open, and it requires #f-resonate. (Dollar signs mark variables; hash signs mark objects. The third sigil is the at sign, for dictionary words. Quotation marks have no special significance.) Dialog can now determine that, since the skeleton requires the animation familiar, and the animation familiar requires the glass case, the skeleton depends on the glass case. The glass case is solved if it is open. So if the glass case is not open, then the skeleton is missing dependencies, and is not currently solvable. So the skeleton should not be highlighted on the map.

2 Likes
128

Yep. The more time I spend reviewing old games for Retro Adventurers the more I’m coming to the conclusion that trying to push way way past verb-noun was, overall, a mistake.

(Came to drop my hot take, not for the first time, that the End of Days was In the End.)

5 Likes
129

I think the need for IF-specific VM platforms could be wildly superseded by standard language (Java, C#, etc) libraries, opening up very different storytelling patterns.

This is the core purpose of designing and building Sharpee.

2 Likes
130

The first problem here is “What standard language?”. The second problem is either having to distribute native code builds—a route few IF authors chose to go down nowadays—or having to distribute whatever language runtime is needed with the game. I suppose you could escape that by using a JVM implementation of whatever language, but using specialised interpreters is perhaps convenient enough for both writers and players to not be worth the consequences of switching from IF-specific tooling.

I imagine you could reply that downloading a language runtime to run a game is hardly much more user unfriendly than downloading an interpreter, but I think it’s plain to see that expecting people to use, say, SBCL would be more of a pain in the arse than expecting them to use Gargoyle.

1 Like
131

These are old problems. C# and Java and most other languages like python, rust, and go are cross-platform and open source, so providing a signed executable is not that big of a deal. Packaging it as a web app is also not that big of a deal.

Pushing the compiled code to WASM in the browser is entirely plausible as well.

My suggestion is that there are interesting and novel possibilities in using a language like C# with LINQ. This gives the author the ability to query the world model for any list or single item under any set of conditions. It also allows for a completely modern architecture where text is emitted after the turn loop ends instead of streaming it throughout the turn loop. This eliminates all of the logic for managing punctuation and white space and allows for templated output queried from the world model state. These things are simply never going to be possible with an existing VM-based architecture.

I think those novel possibilities override the old school VM + interpreter model.

As Steve Jobs once said, “Think Different.”

2 Likes
132

I had the same suspicion. Turns out you’re right.

1 Like
133

This seems a somewhat pie-in-the-sky attitude towards the practicality of cross-compilation.

How would this handle Border Zone type real time events?

Doesn’t Dialog already have somewhat similar capabilities, given its Prolog influences?

1 Like
134

Dwarf Fortress is a commercial game funded by people buying it; someone got paid to write that tutorial. Inform is free software, and relies on community volunteers. Are you volunteering to produce such a tutorial?

(There are books out there about Inform, the authors of which are paid in royalties for having written them; are those not doing it for you?)

5 Likes
135

Er… Defaulting intelligently. :slight_smile: As in not asking the player to supply information that should be obvious. E.g. if a player has a key to a particular door, UNLOCK DOOR should be sufficient to unlock that door, without insisting on explicit use of that particular key (or even just a key). Yes, the player might have used a paperclip (if one were available), but that is a rather less usual action.

3 Likes
136

So… Two words good, four words bad?

I think you might have something here!

137

I still don’t understand why pattern matching or verbose input are worse than intelligent defaulting. Maybe you mean defaulting is less annoying for the player?

138

I hope I haven’t come off as an overreactive curmudgeon, it’s just been a frustrating experience so far. Given how quickly I could understand what other people’s source code was doing, it felt like a sick joke that the IDE was rejecting so much of what I tried to write myself. This is probably an experience everyone here can empathize with, it’s possible I’m just the greenest person here.

I’d agree with you about the paid work on a tutorial, except the Inform IDE was built to put the documentation right there, and the documentation claims the best way to learn is by following through the chapters and examples—all made available for free for what is now decades, so money isn’t the problem.

And no, I’m not volunteering to make a tutorial, because I clearly don’t have the knowledge to teach anyone to use Inform, haha!

My complaint was that the chapters felt non-comprehensive (see: my issue with the lists chapter not naming the possible things which could comprise a list), which was frustrating, because it meant the only code that worked was the example, and anything else I tried based on the descriptive material in the chapter resulted in error after error (see: my error making a “list of texts” rather than the preferred “list of text”).

Now, I say “was,” because while I’ve taken some time off from getting slapped around by Inform, I’ve kept looking at the documentation, and there are some sections where there are reference lists of the sort I want (see: ch. 22.1. A Review of Kinds). This still isn’t comprehensive, but it does mean that other helpful collections like this could be scattered throughout the documentation. I just have to find them…

I maintain that Inform’s official documentation is organized in a way that’s not conducive to my use, let’s say that. I’ve seen Aaron A. Reed and Jim Aikin’s books. The trouble with those are they’re potentially out of date. But if the teaching/organization is better I’ll go with one of those.

Anyway, thanks everyone for humoring me.

I’ll definitely be back with questions! You’ve been very helpful so far, and for that I’m grateful.

5 Likes
139

I’ve posted about 80 question threads in the Inform Authoring category in 3 years. In nearly all of them I have a hissy fit about something related to Inform documentation/syntax. I had about 500 more questions that someone else already asked here so I didn’t have to post a question. So yeah, I can sympathize. Just keep the questions flowing. Don’t let the frustration build up too much before you ask. That’s the ticket.

7 Likes
140

I’m not sure that I understand what you’re envisioning, so my question might be off base. Is this any different from what TADS3 already does/can do? In adv3 at least, all output in a turn is sent to a buffer called a CommandTranscript. The author has the ability to manipulate this transcript however they wish, and the final result is not output to the screen till the turn is truly done. To my mind the punctuation and whitespace are handled pretty painlessly and there is endless opportunity for tweaking or modifying.
I’m also only a beginner in C#, but I would be interested to know what you envision LINQ to do that can’t already be done with chains of TADS3 subset, valWhich, etc. and the opportunity to set up data structures however you want in preinit that could be queried at runtime.
Just trying to get a better understanding!

1 Like
141

Honestly, I don’t think this is a hot take, I think most Inform-users would agree! There is a comprehensive reference like this…

…in the index, not in the documentation. You can only access it from within the IDE after successfully compiling a project. Zed has put a version of it online (if you’re using 10.1), but it’s not part of the standard documentation.

It’s really the missing third part of the documentation (alongside WI and RB), the part that actually lists all the phrase signatures and so on in one easy-to-reference place!

7 Likes
142

I don’t think a VM is necessarily needed at this point, you’re right, but I also think a DSL is generally more appropriate for IF, for one big reason: modern general-purpose languages tend to want to tie behavior to classes, while IF tends to be mostly full of singleton objects with unique behaviors not shared with anything else. The result is, at least in my experience, a lot of boilerplate to patch around the conflicting needs there.

1 Like
143

Absolutely! That and the world map are so, so helpful. I’ll need to study more in the documentation to make sense/use of more of the categories in the phrasebook/rules, but it’s true that there are lists there.

I think what I’ll do is use both halves of the window to cross-reference parts of the documentation with the lists in the index, so I can see the breadth of what’s there, because that’s what I’m missing by studying the documentation by itself.

The fact that I can do that side-by-side stuff in the IDE is great. I’ve appreciated that from the start.

1 Like
144

What if we skip the concept of physical objects and the world model is an in-memory graph?

Then nodes are differentiated by their properties or descending hierarchy.

145

Possible, but I haven’t seen an implementation that convinces me yet. In Dialog, “objects” are just identifiers that rules can be attached to, but it still makes it very easy to attach behavior to specific objects without needing more layers of indirection.

1 Like
146

I don’t think the complexities of delivering a cross-platform .exe are any different than asking a user to download a story file and an interpreter.

If anything, C# could handle real-time event processing better.

I’m not sure Dialog is in my suggestion and I’m not really familiar with it.

1 Like