Jungle adventure

(This is a lightly-edited version of a review I posted to the IntFiction forums during 2022's IFComp).

These days when I’m reviewing a custom-parser game, there’s a little introductory patter I usually launch into where I talk about how back when I was first getting into IF 20ish years ago, seeing that an author had created their own parser for a game was invariably cause for alarm – a sign that I was about to be subjected to an insufficiently-tested, awkwardly-designed system that lacked any of the conveniences that contemporary audiences had justifiably begun to take for granted. But over the years, the quality of custom-parser games has inarguably gotten much better – indeed, one even took fifth in last year’s Comp! – with authors paying attention to what the mainstream systems offer and incorporating most of the same features in their own work.

This trend is a very positive one all around, but here’s a downside – it meant I blithely booted up Jungle Adventure with high hopes for enjoying a round of puzzle-solving and treasure-hunting in tropical climes, and wound up striding gormlessly into a rusty old mantrap of a custom parser that brought me right back to the bad old days.

This is going to be a very negative review, because Jungle Adventure is a badly designed game that’s frustrating in the extreme to play. That’s deeply unfortunate, though, because it’s clear the author put a lot of work and creativity into it. This is most obvious in the detailed, often-clever ASCII art that decorates most scenes – it’s fantastic, with a sense of whimsy and humor (like the bend in the protagonist’s plane once it crashes) that always made me smile. But it’s also reflected in the many different gameplay modes Jungle Adventure boasts; much of it is typical parser fare, but there are also some choice-based sections as well as an extended graphical maze, complete with RPG-style combat.

If the author had a lot of fun putting the game together, though, the player is likely to have no such luck. While most of the puzzles aren’t especially challenging, Jungle Adventure is a beyond-punishing gauntlet of suffering, largely due to the extremely limited capabilities of the parser. From peeking at the python code, in fact it looks like there isn’t really a parser – just a whole mess of hard-coded if-then statements that manually match different input the player types. That means that unless you read the author’s mind and type the exact right thing at every stage, you’re doomed to see a litany of completely unhelpful error messages as the game fails to communicate whether you got a verb wrong, an object wrong, a preposition wrong, or are just barking up the wrong tree.

I’ll restrain myself from offering too many examples, but a few of the most egregious include the fact that neither X nor LOOK AT suffice to examine an object – just LOOK THING; that EXIT means QUIT but LEAVE means EXIT; to get the batteries out of a RADIO you can’t OPEN RADIO or LOOK IN RADIO, just TAKE OUT BATTERIES; and when you’ve got the opportunity to offer an object to another character GIVE RADIO doesn’t work but RADIO does.

Compounding this obfuscated system is an obfuscated game design. While there are hints offered in every room, they’re often fairly cryptic, and I found them inadequate to the challenge of gently leading me to the solutions to puzzles like e.g. the second one, which requires finding the aforementioned radio by intuiting that you’re probably wearing clothing with pockets and typing LOOK IN POCKETS, despite the inventory screen telling you nothing of the sort. Similarly, many of the remaining puzzles require you to squint at the ASCII art and guess what it’s depicting – and which of several synonyms for the object the game will deign to accept. I quickly had recourse to the inauspiciously-named junge_adventure_walthrough.txt (now I really want someone to make the Jung-themed adventure game…) but it only explains the solution to like half the puzzles, and just gestures towards them in general terms when what’s really needed is the exact syntax.

I was able to make it to the end by diving into the aforementioned source code and reading off exactly what I was supposed to do. This didn’t save me from a frustrating time in the maze, though – there’s a lot of randomization here, as well as a bunch of instadeath traps and unbeatable monsters (have I mentioned that there’s no undo, and while there are save slots, there appears to be a bug preventing you from overwriting them?), and a combat system that seems coded such that guns are strictly worse than punching, a fact the descriptions in no way makes clear. Still, I am a cussed, ornery soul on occasion, and I certainly did feel a sense of accomplishment at bashing my head against the maze over and over until I battered my way through – a sense of accomplishment significantly tempered by realizing, after I solved one more puzzle through the expedient of source-diving, that my reward was just a message congratulating me on getting past the first chunk of the jungle, and that there will be more to come once the author gets around to it.

It’s not impossible that part two of Jungle Adventure could be turn out well – stranger things have happened. But to accomplish that, the author will need to do what the authors of custom parser systems have done since they started making them good: look at what the major systems do, imitate them unless there’s a very good reason to drop or change a feature, and test, test, test. As it is, Jungle Adventure Part One is a testbed for some cool graphics and a diverse set of gameplay systems, but I can only recommend it to those looking to bone up on their python-reading skills, or people with disastrously low blood pressure. As released, it’s a frustrating, unrewarding experience that risks resurrecting my old prejudices, though I’m doing my best to fight them.

This seems exactly like the kind of game that would be made by a talented and energetic individual who had never played a text adventure made in the last three decades if they woke up one day and said "I'm going to make the coolest text adventure on earth" but didn't have many people test it.

It's a python game with a bunch of actually really good ascii art. It has a maze, randomized combat, some tricky puzzles, art that sometimes changes according to your actions. Seems like everything a text adventure would need.

Except it has very few of the quality-of-life expectations most parser games have, and many of the solutions are poorly hinted.

For instance, on the very first screen, you are around some trees. Commands like N, NORTH, I, INVENTORY, X ME, LOOK ME don't work at all, but that's okay, this is a custom parser so it has no need to follow conventions from other games. Rereading the help text shows that STATUS gives inventory (although I didn't notice this till later). X TREE and EXAMINE TREE don't work, but LOOK TREE does. It turns out you're supposed to (Spoiler - click to show)CLIMB TREE. Once you make it to the next screen, it's not a big jump to (Spoiler - click to show)LOOK PLANE, but now what? After several fruitless minutes, I turn to the guide to discover I should (Spoiler - click to show)LOOK IN POCKET. But why? If the author had had several people try this game out, they would have found quickly that few people would guess this. You can access a HINT that generally helps you, but most people seem to like games to be solvable without HINTS, using them only when stuck.

The randomized maze combat was hard. I was determined to finish this game, although I kept randomly dying (and there is no UNDO and typing the wrong command after dying exits out of the game entirely, and the command for loading a game during the game is different than the command for loading the game after dying and typing the wrong one will also exit the game as will hitting enter just one too many time). Combat is just pressing enter over and over after picking your weapon, and looking at the code the strongest-looking weapons are incredibly weak while the weakest-sounding weapon is the strongest. There are several insta-deaths in the labyrinth as well.

Overall, it looks like it was magnificently fun to code and make the art, but it doesn't seem like a game that was created with a lot of player-side input, and I ended up frustrated. My 1-star rating is not indicative of the effort put into the game or the total amount of fun that can be derived from it, but merely results from the fact that my usual grading rubric (polish, descriptiveness, interactivity, emotional impact, and replayability) evolved from a different style of text adventure than this one.

(Note: for a much more positive review by a different reviewer, see this link: https://intfiction.org/t/b-j-bests-ifcomp-2022-reviews/57995/3?u=mathbrush)

The fears of some about parser games, especially custom parsers, are fully warranted for Jungle Adventure. It has all the usual faults. But it manages to be fun. I like the ASCII graphics, the whimsicality, the not-too-big maze. And, I admit, I enjoyed peeking in the source code. I'm still not good with classes in Python. Paul Barter is much better than me with them. If JA is whimsical (describing your game as "rip roaring" certainly is bold,) his organization is not, and I learned a lot from it. Hats off to him for that!

The game part is chaotic, though. The parser, first. There're simple verbs that outright clash. You don't want to type just "exit." That exits the game without warning. But "exit plane" leaves your plane, which you need to do. Similarly, LOAD GAME and SAVE GAME are necessary, not just LOAD and SAVE. Some items are implicit in the charming ASCII art or the item description, which is clever until something is forgotten, and you're looking for something that's not there. More seriously, you know your radio must have batteries, because it works, but this is not explicitly described in-game. Then the batteries form part of a neat puzzle. And seeing "oh, hey, this is the part of the ASCII drawing that's not in the text" is neat, but it comes at too high of a price.

The game itself isn't too arduous--well, if you cheat a bit. While there's some guess-the-verb or guess the item, once you get a puzzle, items are swapped and you move on. If something is broken, it's pretty clear you must fix it and how. The maze near the end is not too painful, and the main map is not huge. You'll know what to do. A lot of times you may need to get killed to know what to do, but you'll know. There's humor to keep your spirits up as well. Maybe not Mitch Hedberg or George Carlin, but it's there, and it helped me through some parser-wrangling.

So even if the puzzles take on some additional weight due to you missing the right verbs or nouns (pro-tip: read main.py and scenes/*.py in a text editor) and you have to save-and-restore the fights in the maze (if you get killed while button-bashing, you may be kicked out from the "restore or quit" dialogue, too) it's not too bad. As BJ Best said, there's a certain joy of discovery in Jungle Adventure which more advanced games won't have, and we can lose that if we're not careful. That doesn't make up for serious technical flaws, but for those of us who like writing or playing parser games, it heartens us to try neat new stuff and take on a bit more than we might have felt comfortable with before.

Too many JA style games in IFComp and we might have less patience with the parser. But for me a small handful is always nice, as they never seem to deal with heavy issues, and too often I do not want to deal with heavy issues, even if such efforts are well-written. With JA, there's that genuine joy that, gosh, you can DO something like this, and it succeeds at its goal. And to me it's clear these games are better than they were five or ten years ago, where we have to dig deep to find what the writer was saying, and it's a bit unsatisfactory. JA has a walkthrough now, so IFComp completionists, if you're out there, will hopefully be able to enjoy things more easily. There are frustrations, and a lot of them, but they're (relatively) forgivable. So if you are an IFComp completionist late to the show, you can notice and understand the holes in JA and not feel impeded by them, and the fun I suspect the author had putting JA together will be far less filtered.

Perhaps for a sequel, in addition to a more robust parser, the author will use the colorama package which allows a programmer to specify text color. Then, maybe, the important items could have color in them, while the background is just background. Colorama's something neat I use for my own Python programs to tell when stuff goes wrong, or when a test passes. I think JA shows a lot of potential. With the author's knowledge of Python (I imagine this could expand to learning a testing module as well,) a game design book or two could make something really special, whether for IFComp or elsewhere.