Taking turns with other players (semi-multiplayer IF)

I’d like to see more IF that allows multiple people to enjoy the experience. Note that I’m not necessarily referring to true, real-time networking (i.e. MUDs)

I’m more referring to other ways in which someone might use currently existing IF tools to bring people together to share a story. And if this has been done before.

The first part of the topic is one idea I had was a story that involves multiple characters. Player 1 takes on the role of the first character and plays for a while. When he gets to the end of “Scene 1” or “Chapter 1” the game prompts him to send his saved game to Player 2 who plays another character in another part of the story. Eventually they begin to make decisions and action in the story that affects each other. It seems there are lots of little interactions and ways to play with this concept. What I’d like to explore are ways to make this kind of play possible with the tools already available and what kind of interesting interactions might be possible from this.

Although I’ll admit that this “sending the game to the next player” is very 1990sish and clunky. It’s like running PBEM games.

The second part of the topic is that with today’s asymmetrical gaming, I think there is possibility for multiple players to be able to work together one one IF story without needing to be connected to a MUD and cooperating in real-time. Maybe an extension to Inform 7 could be created to allow this somehow.

Here’s how I would imagine the extension:

Any of the players can sign into a game hosted on a website (the game “knows” that there are now 4 players and which characters they are being assigned to)

The game is paced by scenes or chapters, which can overlap in any way the author would like them to. Here is an example of how it would work:

Player 1 plays Captain Zeff who is conducting a search for one of his pilots on a wild planet. At the end of chapter 1, he receives a transmission and awaits his cryptography team to decode it. When Players 2 and 3 get to a certain part in their Chapter 1, this will trigger the cryptography team’s decoding of the transmission for Player 1.

Thus, Player 1 could stick around in the game and explore around some more, or he can go offline and come back on later to see if his cryptography team has decoded that transmission yet.

So this second thing I’d like to explore is if such an extension is feasible, or perhaps if there is already some other technology out there that does this, that isn’t Inform 7.

Your first suggestion should be dead simple using Inform 7 (or any other development tool, probably). Have a scene that ends when Player 1 accomplishes a certain condition, with a message saying “save the game and send it to your partner.” When the next scene begins, change the player character (with something like “now the player is Pirate Jenny”). Repeat as needed. The different PCs can operate on the shared world in various ways (if Jenny opens a door, it’ll remain open when play switches back to Macheath). There wouldn’t really be much trickery required; it’d be just like a game where the PC’s identity shifts, except that you’re actually expecting players to send save files along so different people play the different PC’s in different stages.

The second one would be trickier… you’d need some way for Inform to talk to a website with shared information. Someone posted a demo for Inform interacting with Javascript; maybe that would be useful? I know zero about javascript though.

Yes, as far as the first goes, I am curious about ideas for potential interaction between players. I know “the sky is the limit”, but that’s always the problem, right? :wink: One thing I was imagining was a story where the players don’t know which characters are being “controlled” by the other players. To them they’re all NPCs, but actually some of those NPCs are the other players causing them to act or believe in certain ways.

Has anyone heard of an IF doing things like this? I’m also kind of interested in alternative ideas of distribution and cooperation than the simple “email your pal”. Maybe a wesbite that disseminates stories that are sometimes fresh, and sometimes “tainted”…

Edit: And on topic 1 and 2, I just found a section in the manual that talks about reading and writing to external files, even files shared by projects or other applications. So it seems there is some potential with that. For example, a story that pulls in voting data from users on website or something like that. Could get into augmented reality stuff with that. Side note: where are the manuals? The only thing I could find on the Inform7 site was the plain text manual.

Suggestion 2 would be, if not trivial, at least very simple with Vorple. It would involve two scripts on the server, one to save the current progress and one to retrieve it at request. The story files would react according to the information they receive.

I could make a quick demo if you’re interested.

The manuals seem to be down on the website at the moment (this has been brought to the attention of the powers that be; there’s a link to vanillla-HTML versions of the manuals). The best way to get them might be to download Inform and look at them in the IDE.

Does anyone know if the vanilla HTML is hosted anywhere? My chromebook doesn’t seem to know what to do with tarballs. Also, when I do get back on a Windows machine, are the manuals in the client IDE at least still available (and up to date)?

Juhana, Vorple is really impressive and I didn’t know it could do that too. Do you mean a demo on the demos page? That would be sweet!

The manuals in the Inform IDE are the most up-to-date ones for that version of Inform. (So e.g. the 6G60 version will have manuals pertaining to 6G60, the 6L02 version will have the reworked 6L02 manual, etc.)

I did shareable chapter save points (unreleased story) by encoding the variables of interest into a printed string. The idea being that players could share their chapter outcomes via any method they choose. It took a bit of coding to create checksums and other little hooks to discourage hacking of the encoding. A similar thing could work for multiplayer without needing a server.
If you wanted to make it particular to two friends then you could have them exchange a randomly generated “callsign” to “synchronise their encrypted comms channel” and then encode + authenticate the callsigns into the messages.

Fighting Fantasy did Clash of the Princes as a two player book. The unique rule was that the players shared a piece of paper with an ACTION and STATUS number but otherwise kept their stats secret. I own a copy but haven’t gotten around to finding a friend to play with me.

I’m familiar with encryption and random seeds, but not enough in their applications to design a functional framework.

If it’s between friends, I’m not concerned about security. Besides, I’m not up to that step anyway. I still have to wrap my head around the possibilities, and I’m not sure I understand yet exactly what you’re suggesting. So let’s start to use terms.


Let’s start with a simple 2 player version to understand it

  • Multiple players can play the game
  • When the 1st player begins, the game prompts to choose “first” or “second” player
  • Then he may begin playing
  • The second player begins on his own machine, selecting to play as the “second” player, and may begin playing
  • At certain points in the story (let’s call them chapters), player1 and player2 (as the game understands it) will not be able to progress
  • At this point, player2 must send some kind of a data file to player1
    • It would be easier if they shared a data file (server), or if the design requires them to write to separate files, the directory is still on a server so that they can read each others’ files
  • As soon as both data files indicate that a chapter is “complete”, then the game state changes and allows the players to progress again

What story elements transfer from player to player? Well, I suppose anything that can be read from the data files. This would be the fun part, IMO.

Assuming the above could work (or is even a good idea), there may already be a problem. I just noticed that the Files section 11.23 of the I7 manual that Glulx is required for data files. So if I want to use Inform 7 along with external data files, I couldn’t use z8? Or is this something Vorple could handle without requiring the Glulx format?

You could use Z8 and Vorple and do all your file I/O through JavaScript (more specifically through PHP or similar via JavaScript).

Rather than use a server, why not have a “enter code” command where the player can then cut and paste an encoded string. The players can play offline and exchange the encoded strings as they feel like it. Maybe via email or paper or something.
The message encoding doesn’t need to be super secure - just enough to make it non-obvious what the contained variables are / do.

Yes, I did respond to your suggestion that it sounds interesting but requires more detailed explanation, since I don’t have any working experience with what you’re talking about.

It reminds me of the NES days when some games, rather than having a savefile, had these very long codes that somehow contained all the savedata.

Going a little deeper into that, how does it work?

Edit: Nevermind, unless I’m misunderstanding you this wouldn’t be sufficient. Those old games only stored very basic game states in those codes, I think. For example, Megaman only really needed to know what level you were on and which powers you had previously collected. The kind of data you would likely want to share between games might be too complex for that kind of a system. More than simple game progression, but things like test strings, NPC behaviors and decisions, etc.

There have been games made in Inform which use Glulx’s file capabilities instead of the usual save system, but I don’t know of any which use a standard IF world model. The general idea is to encode every variable which needs to be saved into a few characters, then concatenate those into a longer “save string”.

Possibly of interest: This Is A Real Thing That Happened is an asynchronous multiplayer Inform 7 game (sort of). I wrote the front end in Inform, and Danielle Church wrote the back end to move data between tables stored in the user’s browser and

And what? And what, by gods?? (Cue overdone grue joke, here?)

Will definitely play this, thanks!

Edit: Played it, loved it. Definitely food for thought. Exactly what I was hoping this thread would be about.

Okay, let me give this idea some more thought, then.

One way it could be done, I think, would be to ensure all variables can be represented via bitwise operators. Those are so small that each variable should be able to be encoded into 1 ASCII character.

This still wouldn’t allow for open ended transferable variables, such as text strings, but constraints are said to inspire creativity.

Here’s a short Halloween-themed Vorple demo.

If you open both Poltergeist and Spooky at the same time, you can open and close a door as a poltergeist and the change is soon reflected in the Spooky version. It works by sending a request to the server every time the poltergeist opens or closes the door where the status is saved to a file. The Spooky version polls the server every 5 seconds to see if there’s any change to the door’s status, and if there is, it sends a hidden command to the story file that opens or closes the door.

In an actual story you’d have some kind of system to recognize the correct pairs, now everyone who plays the Poltergeist version affects everyone who plays the Spooky version.

(The source code might not work on 6L38 because of bug 1413, but should be fine on 6L02.)

Very cool. I suppose if one wants matched games using publicly hosted parchment, we’re getting into username and password territory. Or at least some kind of game ID.

Interesting that you chose the “2 separate games” route. That simplifies some organizational challenges.

I’m not quite sure what you’re saying. Do you mean that you’re going to make each variable one byte wide, so that it can be written to the file as a character? Be careful about different encodings while doing this: ZSCII (the Z-machine character set) and ASCII are very similar, but there are a few differences that will come up if you’re writing arbitrary numeric values. You may want to look into Base64 for this purpose.

Yes, although not so they can be written to file, but so they can be manually entered as a code during play.

Example 2 player asymmetrical game (without requiring shared data files):

Player 1 gets to a certain point in the game. The game gives her the code XUNFJSKN to send to player2 at her leisure. This can be done within the fiction “You log into the terminal and retrieve the code” or simply via some prompt “Your game is saved, please send this code to Player 2.”

When player2 inputs the code (also potentially through the fiction, or otherwise) it changes her game state by setting some known variables. You can incode instructions in the first few variables.

Character/variable 1 might indicate which player N the code is coming from; character/variable 2 might indicate which chapter of the story the remaining characters apply toward, etc.

This is what stormrose was getting at, I think. And I thought you were following up on that thread, as well. Thanks for the tip about the character sets!