Planet Interactive Fiction

October 22, 2014

Renga in Blue

IFComp 2014: Missive

by Jason Dyer at October 22, 2014 05:00 AM

“Oh, Netflix,” you say out loud, while pouring bourbon into a hopefully-clean glass. “My one true love.” The whiskey, your evening, and three episodes of No Reservations disappear. Missive by Joey Fu is in a way another “dual game” like Raik, but instead of simultaneous surrealism two tales are intertwined. It’s the main character’s birthday […]

Post Position

The First Review of #!

by Nick Montfort at October 22, 2014 02:46 AM

Finally, the first review of my book #! is in. It’s from Zach Whalen. this is it, and to make it easier for you to copy, paste, and run it, here is the review that he banged out:

perl -e '{print$,=$"x($.+=.05),map{$_ x($.*.1)}qw(# !);redo}'

By the way, please come to my reading tomorrow at MIT (E15 atrium) at 6:30pm if you’re in the area. It will be fun!

These Heterogenous Tasks

IF Comp 2014: Arqon: A Criminal’s Journey

by Sam Kabo Ashwell at October 22, 2014 02:01 AM

Arqon: A Criminal’s Journey (H.J. Hoke) is a fantasy CRPG-like, parser-based and made in Inform 7. I played Arqon – unusually for comp games – in a small group which included someone who had played before, and was therefore wise to what … Continue reading

October 21, 2014

Emily Short

Dial C for Cupcakes (Ryan Veeder)

by Emily Short at October 21, 2014 03:00 PM

Dial C for Cupcakes is a short parser-based game (45-60 minutes of play time, probably) with gentle puzzles. It’s a sequel to his comp-winning previous work Taco Fiction, but it plays fine even if you don’t remember all the details … Continue reading

Renga in Blue

IFComp 2014: Arqon

by Jason Dyer at October 21, 2014 02:00 PM

You attack the cave spectre, swinging the ancient broad sword, making an attack roll (1d20) of 10, +3 for your level, +2 for being affected by bless – hit (11 to 19), doing 3d4+2 of damage: 3d4+2: 4,3,3+2=12 points – a fatal blow! As the excerpt illustrates, Arqon by H. J. Hoke is a RPG […]

These Heterogenous Tasks

IF Comp 2014: Milk Party Palace

by Sam Kabo Ashwell at October 21, 2014 04:01 AM

Milk Party Palace is a choicey game made in Unity. It is about Alec Baldwin, who really needs some milk for his milk party, and you are the guy to get it. (Which one is Alec? Pretty sure it’s not … Continue reading

IF Comp 2014: One Night Stand

by Sam Kabo Ashwell at October 21, 2014 02:01 AM

One Night Stand, by Giannis G. Georgiou, is a parser-based comedy about a young woman who wakes up in an unfamiliar man’s bed and decides, for Reasons, that she won’t leave until she remembers the guy’s name. This appears to be … Continue reading

Renga in Blue

IFComp 2014: Fifteen Minutes

by Jason Dyer at October 21, 2014 02:00 AM

At 2:25 pm: With practiced brilliance, Sixth You fiddles with the controls of the time machine and vanishes unexpectedly with a crack of inward rushing atoms. You just notice that the array of dip-switches was set to 0100 before the machine, with a hum and a cough, resets itself. With easy nonchalance, Fourth You grabs […]

October 20, 2014

The Gaming Philosopher

These Heterogenous Tasks

IF Comp 2014: Unform

by Sam Kabo Ashwell at October 20, 2014 10:01 PM

Unform (Elize Morgan) is a surreal Kafkaesque dystopian-prison piece, a choice-based work in Twine. “Welcome Prisoner.“ The voice booms across the empty room. You try and get your bearings, you think back to how you found yourself here - and find nothing but … Continue reading

Gamefic

Parser vs. Hypertext: Two Implementations of "Cloak of Darkness"

October 20, 2014 07:01 PM

Last week I updated the Gamefic repo with an SDK that can compile game code into pure JavaScript. There's a standard API that provides functions for sending player commands and receiving game data. Developers can use HTML and CSS to customize the game interface. As an experiment, I used the SDK to compile two versions of Cloak of Darkness. One uses a traditional parser-based interface. The other has a graphical interface that works completely through point-and-click. The world model and solution are functionally the same. Read More

Storycade

News: Anna Anthropy Announces Bundle “Twine and Punishment”

by Amanda Wallace at October 20, 2014 04:01 PM

TwineandPunishment

Game developer Anna Anthropy, also known as Auntie Pixelante, has announced a Twine bundle named Twine and Punishment. This is remarkable for two reasons: 1) no one has apparently named a Twine bundle “Twine and Punishment” before and it’s a definite missed opportunity 2) It features a handful of interesting games.

Twine and Punishment has an announced release date of November 1. The games set to be included are:

star Court

star court

From Anna Anthropy’s site:

star court is based on a little old mac game called kangaroo court that my friend miguel made me play on his little old mac. “it’s basically an anna anthropy game,” he said. when the first witness turned out to be “a very friendly person with large insect-like eyes and a ray gun,” i realized it was true. when the game i had planned for my free patreon last month didn’t work out (it was a writing game, but the scoring mechanisms as they stood didn’t really facilitate writing interesting stories), i decided to write my own version of kangaroo court, set in the queer space opera universe of my other twine games.

by the time i crossed the 11,000 work mark – the size of a very very VERY scary house – i realized the game wouldn’t be done by the end of the month. it ended up my biggest twine project to date, with almost 30,000 words in over 300 passages (v.v.v. scary house, for comparison, has around 200). it’s just really branchy – i wanted it to contain a lot of chance and a lot of choices. and i’m finding it really easy to write for a pulp universe that is basically designed to facilitate as many weird ideas as possible. (spoilers: there is another entry in this series coming up soon!)

Where in the galaxy is kremlin san antonio?

kremlinsanantoniotitle.png

From the itch.io site:

can you follow nefarious criminal mastermind kremlin san antonio’s trail of theft from planet to planet? use the clues you find and your encyclopedia of local worlds to pick up her trail!

mission to planet x

planet X.jpg

From the first page of the Twine:

DEAR AGENT: IN THIS PACKAGE IS A VIAL OF A CONTRABAND SHRINKING AGENT, SHRINKDEX-1. IT COMES FROM THE PRIVATE ARSENAL OF QUEEN LESBIONICA HERSELF. YOU ARE TO DELIVER IT TO AN AGENT OF AN UNDISCLOSED FOREIGN NATION ON THE BORDER WORLD, PLANET X.

the hunt for the gay planet

From Anna Anthropy’s site:

i’ve been saying for a while now that supposedly lgbt-friendly game developers like bioware only see queer people (lgb people, at least) as consumers. nothing could make the point more clearly than bioware’s decision to add gay romances to star wars: the old republic – on a single planet in the galaxy, which players have to pay for the privilege of visiting. pay to enter a dystopian future where queers are exiled to a far-off, backwater planet!

and the robot horse your rode in on

From Anna Anthropy’s site:

i’ll be honest: i made this whole game just so i could write a scene where a girl licks water off the foot of another girl while buried to her neck in the desert. but then i asked myself: why is this girl buried to her neck in the desert? such questions are the seeds of stories. girls who end up buried to their necks in the desert, i thought, aren’t always the most honest banditas. here was an opportunity to explore a conceit i haven’t really spent that much time with: a dishonest narrator. twine was a perfect fit: thanks to the ambiguity of hypertext, the player character can complete her schemes even if the player doesn’t know explicitly what they are.

The bundle will also include the game Keep Dreaming Space Cowgirl, a game I could not find any information on. The Twine and Punishment bundle will be available on November 1. Keep an eye out on Anna Anthropy’s Twitter account for up to date information.

The post News: Anna Anthropy Announces Bundle “Twine and Punishment” appeared first on StoryCade.

Emily Short

IF Comp 2014 Roundup

by Emily Short at October 20, 2014 10:00 AM

I have now reviewed all the comp games I am going to review, which is to say, all of them except a Windows-only work I am not able to play. Most recent years I’ve done an end-of-comp roundup (2013, 2012, … Continue reading

These Heterogenous Tasks

IF Comp 2014: Tea Ceremony

by Sam Kabo Ashwell at October 20, 2014 03:01 AM

Tea Ceremony (Naomi Hinchen) is a parser-based science fiction game. As a junior and not-particularly-capable diplomat, you’ve been tasked with making nice with an alien who has some minor pull in a trade deal, but she’s of a species and caste which … Continue reading

October 19, 2014

Emily Short

IF Comp 2014: Slasher Swamp (Robot)

by Emily Short at October 19, 2014 08:00 PM

Slasher Swamp is a parser-based gross-out horror game, heavy on exploration. I got all the way to the end. This wouldn’t normally be on my review list at all, given that it was distributed as a Windows-only game and I … Continue reading

Renga in Blue

IFComp 2014: Ugly Oafs

by Jason Dyer at October 19, 2014 04:00 PM

A talk slab rests here. It looks written on, yet at the same time, it isn’t silent. Ugly Oafs by Percy Greel is a parser-based wordplay game. The setting is essentially surreal fantasy, but it doesn’t matter: this is all about the puzzles. Unfortunately, the first large puzzle has a combination of bad cluing and […]

Emily Short

IF Comp 2014: Jacqueline, Jungle Queen! (Steph Cherrywell)

by Emily Short at October 19, 2014 12:00 PM

Jacqueline, Jungle Queen! is a comedy parser-IF game with light puzzles. I played it to completion. This is a game that starts out with some tropes about jungle idols and credulous jungle inhabitants that feel like they’re headed somewhere problematic. … Continue reading

Too Much Free Time

IFComp 2014: One Night Stand

by Tracy Poff at October 19, 2014 05:01 AM

The third game I’ve played from the 2014 ifcomp is One Night Stand by Giannis G. Georgiou. You play Sandy, a woman who is trying to discover the name of the man she just spent the night with.

One pre-spoiler note: the download from the comp website just has an HTML file with a link to a web-based version of the game, but the story file can be downloaded, if you follow that link. You’ll need a Quest interpreter to play it.

(This post contains spoilers. Read at your own risk.)

First, a note about online play: the online interpreter was rather slow to react, occasionally taking many seconds to complete a command, and usually missing the first few characters of each command I typed, since it was still scrolling the response text. This was irritating, but it otherwise worked fine, and it was at least visually attractive. Not ideal, but better than nothing, given that I don’t actually have a Quest interpreter.

ONS is a short comedy game with one puzzle sequence. I spent about 35 minutes prodding everything in the game before I finished, but I imagine 10 minutes would more than suffice, if you just proceed toward the goal–and particularly if you aren’t using the rather slow web-based interpreter.

I appreciate the customized responses to trying to take various objects, and the randomly chosen sections of text (e.g. when knocking on Mara’s door) are a nice touch. The ending, though not entirely unexpected, is a good enough payoff for the few minutes the game takes to complete.

On the other hand, you don’t have any real options–either you proceed linearly through the story, or you don’t proceed at all. I wanted to try tricking the dude into saying his name. To break down in tears to avoid the situation. To call him Rumpelstiltskin, if his name is so important. Anything to have some choice–but I had none. More mundanely, there are few objects implemented, and no real, interactive NPCs. The parser is a little obtuse, too: you’ve got to knock door or use bottle on floor, which aren’t exactly the first commands that came to mind.

Overall, an average-quality game, which would probably be more at home in the first ifcomp than the twentieth.

Post-review pre-posting note: Okay, I think this review needs an addendum. Other reviewers seem to be unanimous in despising this game. It was my assumption throughout the game that it was a work of parody–the several-inches deep layer of grease on the kitchen floor not a greater exaggeration than the PC’s absurd internal monologue. Surely the game is so stupid exactly because it’s undermining its nominal position. Of course, while writing the review, I was under the impression that the author was a woman (Wrong! Giannis is a Greek name which is the masculine form Gianna. The more you know.), and that therefore the PC must be a parody of the ridiculous caricatures of women we see in games and other media (maybe not?).

It’s against my policy to change my judgment after reading other reviews, so I’ll let this review stand as-is. I’d rather be too generous in my assumptions about other people than too harsh. In retrospect, though, if you take seriously the bits that I assumed to be failed comedy, then the game really does become rather unpalatable… so take this review with a grain of salt.


Renga in Blue

IFComp 2014: The Urge

by Jason Dyer at October 19, 2014 04:00 AM

You have a kind of agreement with “It”. And even though “It” doesn’t really speak your or any type of language you feel that you’re on terms where the boundaries are drawn. The Urge is a serial-killer story written in Twine by Paperblurt. It’s in the visual novel essentially-no-choices format until close to the very […]

Emily Short

IF Comp 2014: Tea Ceremony (Naomi Hinchen)

by Emily Short at October 19, 2014 01:00 AM

Tea Ceremony is a silly, reasonably easy parser-based puzzle game about satisfying the etiquette demands of an alien dignitary. I played the game to completion. This is not a game that will require a great deal of your time. It’s … Continue reading

October 18, 2014

The Gameshelf: IF

Zarfplan: Awaiting approval

by Andrew Plotkin at October 18, 2014 04:28 PM

On November 1, 2010, I opened a Kickstarter project for an iOS text adventure.

Last night I submitted the Hadean Lands iOS app for App Store approval. (And also uploaded it to the Itch.IO and Humble distribution platforms.)

As I said, this will be a simultaneous release on all platforms. So we're now at Apple's mercy -- not an unfamiliar feeling for modern game developers. According to the charts, the iOS approval process is currently running about eleven days. (I'm used to five or six days, but I figure they're swamped with app updates for iOS8 and the newest phones.)

I am targetting October 30 as the launch day. That means you'll be playing the game on the fourth anniversary of the Kickstarter launch. Tidy! If it looks like approval is going to run longer, I'll let you all know.

In the meantime, you can take a gander at the Hadean Lands web site, which is now up and running. The map is the game's big "feelie". Old Infocom fans will get a kick out of the IF sample transcript -- no spoilers for the game itself, just an example of how alchemical IF plays out.

So what will happen on (I hope) Oct 30?

  • You will see the game appear in the iOS App Store. (Don't buy it yet!)
  • You will see Itch/Humble widgets on the HL web page.
  • If you asked for an Itch/Humble download key, you will get email (from me) containing that key.
  • If you asked for an iOS app, you will get email (from Apple) notifying you that the app has been credited to your iTunes account.

The last bit is the tricky one. I will be gifting the app directly to all US-based backers. But Apple doesn't allow gifting between countries. So if you're outside the US (or your iTunes account is), I'll have to do some dancing.

Here's what I figure: for the major countries (UK, Canada, Australia, a few others) I will pick somebody I know and PayPal them a bunch of money. That person can then do the gifting. If you're the only person from your country, I'm afraid I'm going to have to contact you directly and PayPal you US $5 -- then you can just buy the app.

(I will be contacting you directly to talk about PayPal matters.)

I realize this is a hassle, and it may take extra time for non-US backers to get their iOS app. I'm sorry; I don't know a better way to do this. (Other than opening bank accounts in a dozen different countries, which I can't manage.) I was hoping that a solution would turn up before the game was finished... Fortunately, none of this hassle applies to the Itch/Humble downloads, so those will all go out on time.

I still have not started to plan the physical rewards. One thing at a time.

October 17, 2014

Post Position

#! Reading at MIT, Wednesday, 6:30pm

by Nick Montfort at October 17, 2014 09:24 PM

Nick Montfort presents #! in the atrium of MIT’s building E15, just steps from the Kendall T stop. It’s October 22, Wednesday, at 6:30pm, and thanks to the List Visual Arts Center. The book is Montfort’s new one from Counterpath Press, consisting of programs and poems. Please, come join me!

E15 Atrium

Too Much Free Time

IFComp 2014: Raik

by Tracy Poff at October 17, 2014 08:00 PM

The second game I’m looking at this year is Raik by Harry Giles, which is written with Twine. According to the blurb, it is “A scots fantasia about anxiety. Battle kelpies, watch TV, avoid your emails and find the magical Staff of the Salmon.” Sounds amusing!

(This post contains spoilers. Read at your own risk.)

My spoiler warning above goes double for this game. Really definitely don’t read this without playing the game. I mean it.

When you start the game, you’re advised that you can “Learn about Scots and use a translator at Scots-Online.org“, and you are presented with a pair of links: gang and go. It looks from the outset as if the game is simply available in two languages–Scots and English–for flavor, and the “Translate to Scots” and “Translate to English” links that appear reinforce this. The text is even very similar in shape in each language. However, this is only a facade: there are two stories being told, and they are superficially unrelated.

In the Scots-language story, the PC struggles through the day, trying to fill time: “If ye can get tae hauf five, mebbe ye can get tae dinner, than mebbe ye can get tae bed.”

In the English-language story, the PC is on an epic quest: “You are searching for the Staff of the Salmon, whose magic alone will release your clan from the withering curse of Black Edward.”

At the bottom of each page of text is an option to ‘translate’ into the other language, which actually presents not a translation but the section of the story which is in the corresponding position in the other language: the stories are structurally the same. They are related in more ways that one: at the end of the English-language story, “You imagine another version of yourself, who stayed in bed that fateful day and even now lies frozen in time, unable to act, an endless scream seeking only relief.” In the most recent corresponding part of the Scots-language story, the PC is paralyzed by a panic attack.

My interpretation: the Scots-language story is ‘real’, and the English-language story is the PC’s way of dealing with life–or of not dealing with life, as the case may be.

The duality of the stories is very cool and well done. Though you could (mostly) play them separately, the English-language story serves as commentary on the Scots-language story. For example, when the PC of the Scots-language story is (figuratively) lost in a panic attack, the PC of the English-language story is (literally) lost in a maze. It’s an impressive way to use metaphor.

The individual stories are well-crafted, too. I particularly liked the use of links to pace the story. Early on, links interrupting the text make the story seem to move slower, but later they make the pacing seem more frantic–well done!

You’ll note that my praise is all for ‘meta’ aspects of the game–this is not an accident. The actual game isn’t all that interesting. The Scots-language story is dull (but it’s supposed to be, since it’s the ‘real-world’ part of the game) and the English-language story is far from engaging. However, the game is quite short (about fifteen minutes for a single playthrough), so this wasn’t a problem.

The language aspect could prove something of a problem. It’s easy enough to tell the general sense of the Scots-language story, but for most readers there will be many specific terms that require definition. It’s certainly the author’s intention to induce readers to learn more about Scots, which is fine, though I wonder how much effort the (non-comp-judging) general public will be willing to expend on comprehension. My own experience with Scots (other than Robert Burns) is limited to an encounter with the Scots Wikipedia, some years ago. At the time, I judged that the editors were treating Scots as a somewhat more dignified version of leet-speak, and put it from my mind. It seems to have done better since, though it still has very few editors.

According to the author, Raik was inspired by Depression Quest, which I have not yet played. I’d like to come back to this game after playing Depression Quest, to see how it affects my opinion. At any rate, I foresee myself continuing to revisit and think about this game in the future, which is about the highest praise that can be given to a ‘serious’ game like this.

Play time: about 40 minutes for several playthroughs.


Storycade

[Kickstarter] Ice-Bound: A Novel of Reconfiguration

by Amanda Wallace at October 17, 2014 04:01 PM

Ice-Bound

The creators of Ice-Bound, Aaron Reed and Jacob Garbe, call it a novel of reconfiguration. It’s closest corollary is either Reed’s 18 Cadence or very unique works of fiction like House of Leaves. 

It’s easy to say what Ice-Bound is not. It is not traditional IF.

It becomes more difficult to parse what the game is, as it defies explanation by simply creating it’s own sub-genre. Ice-Bound is an indie game, a work of electronic art where collaboration between the real world and the fictional is paramount. As the developers say in their Kickstarter video — it’s the games primary mechanic.

In keeping with the stated inspiration of novels like House of Leaves, Ice-Bound is a fragmented story. The stories nest inside of one another — the tale of an abandoned polar base, a dying authors notes, a confused AI that you must lead towards the truth. The story alone could be enough to sell you on this Kickstarter. But that isn’t all that the developers are offering.

Ice-Bound

One of the primary components of the game is a physical book — the author’s notes from an incomplete masterpiece. The game operates by having you show portions of the book to the camera on your Windows device or iPad, which gives the AI (the game) the ability to figure out more of the story. It’s a fascinating interplay of concepts that looks like it combines elements of Aaron Reed’s interactive non-linear experience 18 Cadence and Jacob Garbe’s Closed Room, Soft WhispersThe game is on the bleeding edge of emergent fiction and augmented reality experiences, and promises to be the next great experimental hit in the interactive fiction community.

The game is already funded, but there is still time to back the project before it concludes on November 5. $20 will get you a copy of the Ice-Bound Compendium (the physical component) as well as access to the game. You can find out more at the Kickstarter page.

The post [Kickstarter] Ice-Bound: A Novel of Reconfiguration appeared first on StoryCade.

Too Much Free Time

IFComp 2014: Hill 160

by Tracy Poff at October 17, 2014 04:00 PM

A new year brings a new ifcomp. The first game, this year, is Hill 160 by Mike Gerwat, billed as “A World War I Adventure in Terror”. This appears to be Gerwat’s first comp entry, though he has released another game, Genesis Quest, which is available on the ifarchive.

(This post contains spoilers. Read at your own risk.)

Sadly, this first game is one I couldn’t finish. The author indicates that this game has been made easier to comply with the comp rules (the two-hour rule, I suppose), but I sincerely doubt that anyone will finish the game, because the walkthrough is a bit over 700 commands long. To complete the game you’d need to execute one (correct!) command every ten seconds. Judging by the walkthrough, in 48 minutes I got through about a sixth of the game.

If the game were only too long, I would have continued to play for the full two hours games are allotted. Unfortunately, the game has three crippling flaws: first, it is tedious; second, it is unfriendly (more on this later); third, it is buggy.

The tedium is, I presume, intentional: it’s intended to reflect the tedium of war. To that end, the game involves plenty of actions that are boring, repetitive, or both. The walkthrough contains (from about 700 turns) 57 turns of waiting, 19 turns of sleeping, and 16 turns of ‘again’, which are mostly sleeping or waiting. When you are acting, you are often doing something like drop pants / crap in trench / pull up pants.

The unfriendliness is the main reason I gave up. Any little thing you do that isn’t according to script will generally end the game. Leave the latrine without using it? “You didn’t take your shite! GAME OVER MATEY!”. Walk onto the battlefield without cleaning your rifle? “You didn’t clean your rifle! GAME OVER MATEY!”. Try to take the supplies you’re after, rather than asking for them? “GAME OVER MATEY!”.

It’s not generally obvious what you’re meant to do until you’ve already failed. How was I to know I had to clean the rifle? It’s description didn’t mention anything. For that matter, how was I to know I had to attach the bayonet myself? The game over message tells me that “Your rifle is missing a critical part.”, but attempting to examine it again gives me “You’ve already examined the rifle.”. The game won’t let you examine anything twice, or talk to anyone twice. If you don’t have a transcript, you’d better have remembered the names of the members of your platoon–you won’t be seeing them again!

It’s not always obvious how to accomplish things, either. When you’re sent for supplies, trying to simply take them from the supply party gets you killed, but talk to party gives “You can’t talk to the supply party.” In fact, you must ask party for supplies. But talk to grant worked, earlier. The requirements are inconsistent. Once, when talking to Grant, you must salute (or game over!), but later, saluting isn’t necessary.

Finally, the game is buggy. If you talk to Grant in the Main Trench before going out on the recon mission, he gives the speech that he gave earlier about you needing to go pick up supplies. Waiting repeatedly will repeatedly give the text about Grant arriving. Sometimes waiting will just do nothing with no message at all. And it’s not strictly a bug, but take all should not open up every container and fill my inventory with several screens worth of cigarettes and grenades and things. It should just pick up the items I dropped. Very irritating!

All that said, the game does have its good points. The author indicates that it’s intended to be fairly realistic, based on his over 40 years of study, and there are plenty of interesting details. There are some detailed descriptions of certain items, and the language and situation are (apparently–the first World War is not my forte) also intended to be realistic. For my part, I’d enjoy it more simply exploring the environment than having the game nag at me about every minor detail (and the author promises that “When it goes up on the archive, it will be much harder with Release 2.” Not necessary!).

Hill 160 has potential, but I won’t be returning to the current release.

Play time: 48 minutes.


The Digital Antiquarian

The Forth Dimension

by Jimmy Maher at October 17, 2014 02:00 PM

Forth

The Forth programming language reached maturity around 1970 after more than ten years of development and experimentation by its creator, Charles H. Moore. Its first practical use was to control a radio telescope at the National Radio Astronomy Observatory, where Moore was employed at the time. From there Forth spread to other telescopes and other observatories, cementing a connection with astronomy and space science that persists to this day; in addition to controlling countless telescopes and planetariums earthside, Forth has been into space many times on probes and satellites of all descriptions. Yet already by the end of its first decade Forth had spread far beyond astronomical circles. It was being used to control the motorized cameras used to film miniature-based special-effects sequences (suddenly a booming business in the wake of Star Wars); to control automotive diagnostic equipment; as the firmware in various medical devices; to control automated agricultural equipment. Closer to our usual interests, Atari had invested a lot of money into developing a version of the language suitable for programming pinball machines and stand-up arcade games, while versions of the language were available for all of the trinity of 1977 within a year or so of their appearance. The key to Forth’s burgeoning popularity was its efficiency: it not only ran faster than just above any language short of assembly, but in the right hands it was also almost unbelievably stingy with memory. Those were good qualities to have in the late 1970s, when the average PC ran at 1 MHz and had no more than 16 K.

We’ll get into why Forth is so efficient in just a bit. But first let’s take a look at the language itself. If you’ve programmed before in just about any other language, Forth will likely seem deeply, deeply weird. Still, there’s also something kind of beautiful about it. If you’d like to follow along with the few examples I’ll give in this article, you have many free implementations of the language to choose from. A good choice, and one that has the advantage of working on Windows, Macintosh, and Linux alike, is Gforth.

Forth is an interactive programming language, like the microcomputer BASICs so many of us grew up with. This means that you can enter commands directly at the Forth console and watch them run immediately.

Forth is also a stack-based programming language, and this is the key to everything else about it. Virtually every programming language uses a stack under the hood; it’s one of the most fundamental mechanisms of computer science. But most other languages try to hide the stack from us, strain to make it so that we need not trouble ourselves over it and, indeed, don’t really need to know much about it at all. The only time many programmers even hear the word “stack” is when an infinite loop or runaway recursion causes a program to crash with a “stack overflow error.” Forth, however, doesn’t hide its stack away like something shameful. No, Forth loves its stack, sets it front and center for all to see. Forth demands that if we are to love it, we must also love its stack. Given this, it would behoove me at this point to explain just what is meant by the idea of a stack in the first place.

A stack is just that: a stack of numbers stored in a special part of memory, used for storing transient data. Adding a number to the stack is called pushing to the stack. It always goes on top. Taking a number from the stack is called popping the stack. It’s always the top number — i.e., the most recently pushed — that’s popped, after which that number is erased from the stack. A stack is, in other words, a first-in-last-out system — or, if you like, a last-in-first-out system. If you haven’t quite wrapped your head around the idea, don’t sweat it. It should become clearer momentarily.

Let’s look at how we can do simple arithmetic in Forth. Let’s say we want to add 2 and 3 together and print the result. In a typical modern language like Java, we’d just do something like this:

System.out.print(2 + 3);

In Forth, we do it a bit differently. If you’ve started up a Forth environment, you can type this in and see the result immediately.

2 3 + .

If you happened to use a Hewlett-Packard scientific calculator back in the day, this notation might look familiar to you. It’s known as “postfix” or “reverse Polish” notation. Let’s unpack this piece by piece to see how exactly Forth is handling this expression.

The first thing to understand here is that Forth reads almost everything as a word — Forthese for a command. A number standing by itself is actually interpreted as a word, a command to push that number onto the stack. Therefore, assuming we started with an empty stack, the stack looks like this after the first two parts of the expression above have been processed:

3
2

Now the interpreter comes to the “+,” which is also read as a command, instructing it to pop two values off the stack, add them together, and push the result back onto the stack. After doing so, the stack looks like this:

5

Finally, the “.” just instructs the interpreter to pop the top value off the stack and print it.

Now let’s consider a more complicated algebraic expression, like “(4 + 5) * (6 + 7).” In Forth, it would be written like this:

4 5 + 6 7 + * .

Let’s walk through this. We push 4 and 5 onto the stack.

5
4

We pop them off, add them together, and push the result to the stack.

9

We push 6 and 7 onto the stack.

7
6
9

We add them together and push the result.

13
9

We pop the top two values on the stack, multiply them together, and push the result.

117

And finally we pop and print the result.

To this point we’ve been working interactively. The key to programming in Forth, however, is to define new words; this is Forth’s nearest equivalent to the function calls common to other languages. Let’s consider a function to cube a number, which would look like this in Java:

int cube (int num) {
   return (num * num * num);
}

In Forth, we might do it by entering the following lines at the console:

: CUBE ( N -> N. Cube a number)
   DUP DUP ( Now there are three copies)
   * * ( Get the cube)
;

Let’s again unpack this piece by piece. The colon is a word which tells the interpreter that what follows will be a new word definition, to be terminated by a semicolon. “CUBE” is the name of the new word we are creating. All text within parenthesis are comments, to be ignored by the interpreter. The “N -> N.” notation within the first parenthesis is not required, but is considered good practice in Forth programming. It tells us that this word will pop and operate on the current topmost word on the stack, and will push a single result onto the stack. Forth words do not take arguments like functions in other languages, but operate only on the current contents of the stack. Thus it’s the programmer’s responsibility to set the stack up properly before invoking a word, and to know what that word will have done to the stack when it finishes. The two lines in the middle are the meat of the word, the actual instructions it represents.

Let’s say we call this new word “CUBE” with a 5 on top of the stack — i.e., by entering “5 CUBE .” at the console. Thus the initial stack looks like this:

5

Now we’re going into the body of the word itself. The two “DUP” statements tell the interpreter to duplicate the top value on the stack twice, without destroying — i.e., without actually popping — the original value. So, we end up with:

5
5
5

Now we pop the top two values, multiply them together, and push the result.

25
5

Then we just do the same thing again.

125

And our work is done.

Next we’ll see how we can use this word within another word. But first let’s see how we would do that as a function in Java.

void cubes10() {
   for (int i = 0; i < 10; i ++) {
      System.out.print("\n");
      System.out.print(i + " ");
      System.out.print(cube(i));
   }
}

Here it is as a Forth word:

: CUBES10 ( ->. Print a table of cubes of 0-9.)
   10 0 ( Indices of loop)
   DO ( Start Loop)
      CR I . I CUBE . ( Print a number and its cube.)
   LOOP ( End of loop.)
;

As the first comment indicates, the “10CUBES” word expects nothing on the stack and leaves nothing there. We begin by pushing 10 and 0 onto the stack. Now Forth’s back-asswordness really comes to the fore: the “DO” word pops the last two words off the stack. It will increment a variable — always known as “I” — from the second of these until it is equal to the first of these, looping each time through the block of words contained between “DO” and “LOOP.” Within the loop, the word “CR” simply causes the cursor to move down to the next line. Keeping in mind that “I” represents the current value of the variable being incremented, which can be pushed and popped just like a constant, the rest should hopefully be comprehensible. The output looks something like this:

0 0
1 1
2 8
3 27
4 64
5 125
6 216
7 343
8 512
9 729

Forth is built entirely from words like the ones we’ve just created. In fact, calling Forth a programming language may be something of a misnomer because virtually every piece of its vocabulary is redefinable. Forth comes with a dictionary of common, useful words, but the programmer is always free to replace these with others of her own devising, to make Forth into whatever she wants it to be. The most basic words are not constructed from other Forth words but rather written as in-line assembly language. The programmer adds words to this base which do ever more complicated tasks, until finally she writes a word that subsumes the entire program. To take an example from Leo Brodie’s classic book Starting Forth (one of Forth’s chief products down through the decades has been horrid puns), a Forth program to control a washing machine might have this as its top-level word:

: WASHER
   WASH SPIN RINSE SPIN
;

Each of the words referenced within “WASHER” would likely call several words of their own. “RINSE,” for instance, might look like this:

: RINSE
   FAUCETS OPEN TILL-FULL FAUCETS CLOSE
;

Each of these words would call still more words of its own, until we come to the level of fundamental assembly-language commands to control the CPU on its most basic level. Forth words can even create new words dynamically, resulting in programs that effectively rewrite themselves as they run to suit their environment.

Especially if you’re a programmer yourself, you may have already formed an impression by now of Forth’s strengths and weaknesses. And yes, contrary to the claims of many Forth zealots, the latter do exist in considerable numbers. Even leaving aside the strange reverse notation, which one can eventually get used to, Forth programs can be incredibly hard to actually read thanks to their reliance on pushing and popping to the stack, with the associated lack of helpful variable names. For this reason Forth has occasionally been called a “write-only” language; Forth code can be well-nigh incomprehensible even to the person who originally wrote it after just a week or so has elapsed. It’s the polar opposite of a contemporaneous language I once wrote about on this blog, Pascal, replacing the latter’s pedantic emphasis on structure and readability above all else with a love of hackerish tricks, sleight of hand, and cleverness that can sometimes come off as sort of facile. Just trying to keep a picture in your head of the current configuration of the stack, something on which absolutely everything you do in Forth depends, can be a nightmare as programs get more complicated and their possible states get more varied. If not quite the last language in the world I’d use to write a complicated modern application, it must be pretty close to it. It’s “write-only” qualities make it particularly unsuitable for team projects, a problem given that most useful software long ago got too complicated for solo programmers.

Yet there’s also an uncompromising beauty about Forth that has drawn many people to it, a beauty that has occasionally been compelling enough to override people’s better judgment and make them use the language for purposes to which it really isn’t terribly suited. Whatever else you you can say about it, it sticks to its philosophical guns tenaciously. There’s a fascination to building a dictionary of your own, to effectively making a programming language all your own. Grizzled Forth programmers have often replaced virtually everything that comes with the language to create something that is absolutely theirs. That’s a rare experience indeed in modern programming. People who love Forth really love it. This (in Leo Brodie’s words) “high-level language,” “assembly language,” “operating system,” “set of development tools,” and “software design philosophy” has that rare ability, like my old love the Commodore Amiga, to inspire a level of visceral, emotional commitment that smacks more of romance or religion than practicality.

If we do insist on speaking practically, within certain domains Forth excels. It’s still widely used today in extremely constrained environments where every byte and every processor cycle counts, such as, well, the firmware inside a washing machine. To understand what makes Forth so efficient, we need to first understand that those more readable Java functions I showed you above must ultimately be converted into a form pretty close to that we see in the Forth versions. By making us meet the computer halfway (or further), Forth eliminates a whole lot of shuffling about that costs precious processor time. A well-written Forth program can actually be smaller than its pure assembly-language equivalent — much less the same program written in some other high-level language — because Forth so emphasizes reusable words. And it can be surprisingly easy to port Forth programs from computer to computer; one need only re-implement that bottommost layer of words in the new machine’s assembly language, and leave the rest alone.

Of course, all of these advantages that make Forth so attractive to programmers working on embedded systems and device firmware today also made it mighty appealing to programmers of ordinary PCs of the late 1970s and 1980s, working as they were under stringent restrictions of their own. For some early PCs Forth was the only language other than the ROM-housed BASIC or assembly language that made any sense at all. Stripped down to its essentials, Forth can be tiny; for example, Cognetics Corporation, a developer we met in a recent article, worked with a version of Forth that fit into just 6 K. Thus Forth enjoyed considerable popularity, with a fair number of games and other commercial software written in the language. John Draper, the legendary “Captain Crunch” who taught Steve Wozniak and Steve Jobs how to phone phreak amidst myriad other hacking accomplishments, was a particular devotee, distributing a Forth development system for the Apple II which he also used to write the II’s first really usable word processor, EasyWriter. Many of the magazines ran columns or extended series on Forth, which was available, and generally in multiple versions, for virtually every remotely viable machine of the era. One British computer, the ill-fated but fascinating Jupiter Ace, even included Forth in ROM in lieu of BASIC. Tellingly, however, as the 1980s wore on and software got more complex Forth became less common amongst commercial application and game developers, even as it retained a dedicated cult of hobbyists who have persisted with the language to this day. According to Charles Moore, this was as it should be. Forth, he told Jerry Pournelle in Byte‘s March 1985 issue, had never been intended for closed-source commercial software.

Writing big programs to be distributed in object code is a distortion of what Forth is all about. Forth is like a set of craftsman’s tools. You use it to make still more tools that work with whatever you specialize in. Then you use it to solve problems. Forth programs should always be distributed in source code. You should have Forth online at all times. Recompile whenever you want to use a program. Forth programs are tailored, they’re living and dynamic, not static object code.

“Distortion” or not, the most important Forth game, and arguably the most ambitious project ever completed in the language, would appear more than a year after those remarks. I know I’ve been teasing you with it for a while, but, with all the pieces in place at last, we’ll get there next time… really, I promise.

(Probably the best place to look to get an idea of the excitement Forth once generated, as well as a very good picture of the language itself, is the August 1980 Byte, which had Forth as its main theme. My example code in this article has its origins there, as does the picture.)


Comments

October 16, 2014

Far Far Futures

Eidolon — A. D. Jansen

by Joey Jones at October 16, 2014 09:01 PM

Well behind schedule, this is the first of the 42 IFComp 2014 entries I intend to review. A lot of …

Continue reading

The Textfyre Times

What Color is My IF Parachute?

by David Cornelson at October 16, 2014 07:00 PM

So I started Textfyre somewhere around 2006-2007. The corporation was legally created in March of 2007, but I had done a lot of research before that point. We released Secret Letter and Shadow in 2009.

Eventually I will write some sort of historical essay on the rise and fall of Textfyre, since at this time, it looks like I will be closing its doors at the end of the year, releasing IP back to authors, and open-sourcing all generic code. I’m still on the fence about this, but unless I have a compelling reason, Textfyre will end on Dec 31st of this year.

I still need to publish the Windows 8 Store version of Shadow. I’m waffling on it for the moment. It will just never be as good as I want it to be. It’s hard to do this stuff alone. I had help last year, but that help has for the most part disappeared.

* * * *

This does not mean I have lost one bit of passion for IF, commercial IF, educational IF, or any of the ideas or visions I’ve worked on for the past 8 or 9 years. It’s just a reality of the day. There are better people at it, specifically Choice of Games, Inkle Studios, and Versu. The emergence of Twine and CYOA games also leads me to believe we’ve hit a crossroads with parser-based IF and I still love parser-based IF. I think the art of IF within Twine and the new iPad games is very compelling. It’s much closer to what I envisioned than I could ever manage.

So what’s next. Well I think I will place my IF passions back to where they were. As a hobby, a passion, and an artistic endeavor. The plan have at the moment is to develop a JavaScript version of FyreVM using Quixe and then building a CLI based IF-builder the same way Ionic builds mobile applications. I envision it something like this:

You type a command in like…

zifmia start mygame z-standard

…and this creates scaffolding for a web-based interpreter using your game file. It automatically generates an I7 extension to be used by your game. You then go write your game in Inform 7 and when done, you save the ulx/blorb file in a directory within that scaffolding. Then you can serve it for testing:

zifmia serve

That command will open a browser running your game in the given template. The template can be modified if you know HTML, CSS, and AngularJS.

When you’re done and ready to publish, you type…

zifmia publish

…and this will create a package you can drop on a server.

I’ll finally be able to develop the templating system I envisioned for Zifmia years ago and by generating the extension in conjunction with the template, authors will have detailed instructions on how to write their game for a given template.

It will be easy.

* * * *

So that’s the new plan. Plans change of course, but this is where I’m headed. As I said, if and when I do close Textfyre, I will write a very thorough accounting of its history for anyone interested. Even so, I could not have done it without the following people:

Jesse McGrew – coded FyreVM from scratch and my hair-brained design requests about Channel IO in about 80 hours which is still an amazing accomplishment.

Mike Gentry – for flying out to Chicago on several occasions, busting his ass to write Secret Letter on paper when no one else had ever done that before. An amazing accomplishment and not just for Textfyre. I’m sure his efforts carries into other people’s IF design endeavors. And for writing Secret Letter itself, which despite its flaws and criticisms, is a wonderful game.

Jon Ingold and Ian Finley – for creating Shadow in the Cathedral, one of the best IF games I’ve ever played. I have played it hundreds of times and I still love it. I wish we could have done the sequels.

Paul O’Brian and Chris Huang – for designing Empath’s Gift and suffering through endless attempts to complete the code. Maybe it will still be finished. I hope so.

For everyone that offered their support. I could not have done even what I did accomplish without the IF community.

I’m not going anywhere….just returning to a hobbyist and an enthusiastic cheerleader of IF.


October 15, 2014

Quest

Open-sourcing “Moquette”

by Alex Warren at October 15, 2014 07:00 PM

A year ago, I released my first work of interactive fiction “Moquette” into the IFComp.

Today, I’m releasing the source code for it: https://github.com/alexwarren/moquette

It might be useful if you’re interested in implementing similar text effects in your own Quest game – if so, this blog post may also help.

Or who knows, maybe you’d like to adapt it – fix up the writing, change the ending, whatever… you can now fork it and do what you like with it.

The commit history goes all the way back to when it was a very primitive London Underground simulator, so you can see how it evolved over time. You can see the bursts of activity on GitHub’s commit graphs, which give some indication of the ebbs and flows of my energy for writing.

I haven’t had so much energy for writing for the last year, though I’m kicking around ideas again. Who knows where they will end up. Perhaps we haven’t yet heard the last of Private Rod…


>TILT AT WINDMILLS

"how do you Do it": You Might Have Won

by Aaron A. Reed (noreply@blogger.com) at October 15, 2014 04:17 AM

Being chained to my own game's booth at IndieCade, I was rarely able to escape and play with this year's spectacular lineup. One of the finalists I have gotten to try is "how do you Do it" by Nina Freeman and Emmett Butler, with art by Jonathan Kittaka and audio by Deckman Coss. The game takes only a few minutes to play and is available for free online: it would take longer and be less interesting for me to explain it than for you to just try it yourself.

One thing I love about this tiny game (made in the 2014 Global Gam Jam) is how deftly it uses game conventions to comment on early-adolescent angst about the mysteries of sex: your reddening cheeks and changing expressions as a supposed status indicator to some complex internal state; the awkward controls; the score screen's numerical judgment and tacit implication that maybe you could have done better. The game both pokes fun at drawing parallels between the things important in sex and games, while also raising those parallels, along with one cheeky eyebrow: and I suppose learning a new game can be similarly anxiety-inducing, especially if it's tinged with worry that other people are figuring it out (and getting better at it) more quickly than you... 


It also made me think about how games transmit cultural values. In the same way prior generations learned about gender roles and sexual norms from movies, we're now transmitting these values to younger generations--mostly unconsciously--through games. What are the games we play teaching adolescents about sex? Are we okay with that?

"how do you Do it" was made with Flixel, a free and open source game-making library, and its source is also freely availableNinaEmmett, Deckman, and Jonathan all have more work available on their websites.