Link to the Game >  https://bartleby.nfshost.com

This is my final project for DHUM 72000 Textual Studies in the Digital Age [Fall 2020] with Professor Jeff Allred.  Here are the criteria the professor asked we consider when creating a project.

• Design: is the object easy to navigate and clearly organized? Does it have mistakes in its text, broken links, or other infelicities? Does it use a platform or technology that is appropriate to the message it seeks to convey?
• Argumentation: does the object have a clear argument or narrative? Does it take users from point A to point B in a clearly articulated way?
• Audience: does the object communicate to a well-defined audience? Is it properly pitched to that audience?
• Reflectiveness: Is there some kind of reflective writing that contextualizes the object for its audience (or analyzes it for my benefit)? [Does the author] show an awareness of how the object relates to other similar efforts in circulation, or to the long history of reading we’ve examined in the course? (Allred)

I will tackle each criterion, but you, gentle reader, will be the final arbiter on whether I succeeded.

Design

For simple game design, the professor suggested a programming language I did not know called Twine.  Twine is an “open-source tool for telling interactive, nonlinear stories” (About Twine).  Poking around its site and playing some of the games people had made with it, I started thinking about how I might have fun with an existing story.  Bartleby, the Scrivener came to mind.  We had used Bartleby to create an audiobook for an earlier class project and that process had reminded me how much I enjoyed reading Melville, and how much (and how little) of Melville’s New York remains.  I love New York City and its history is a passion of mine.  I started thinking about how a story like Bartleby might be used to share a bit about what New York was like in the 1850s by following its characters around when they were outside of Melville’s narrative.

Working with Twine is tricky. Its original developer no longer maintains it.  Now folks with an interest make adjustments.  Its wiki is not being kept up-to-date, so the screenshots in the wiki don’t match the current GUI of the program.  In practice, that means a lot of the learning is hit-or-miss.  The most recent code is Twine 2.0 and its default story format uses the Harlowe markup language.  Having done CSS and HTML coding by hand, I thought it would be simple.  However, figuring out how to best link each passage and allow link-backs took some doing.

In theory, Twine should be able to use set-calls to create simple RPG functions, like a health-point inventory to step the player through a script.  My original skeleton included a countdown script that depleted each time a character entered a passage and was to be timed so that the player could never get to the Tombs in time to save Bartleby before he was out of health-points.  In practice, Twine didn’t recognize the initialization passage using the current Harlowe calls.  A day spent researching on the Twine Wiki and the GitHub repository for Harlowe left me without any helpful solutions beyond scraping Twine and writing the entire thing in Harlowe.  Since the assignment was to use Twine, and I had already coded everything but the game-calls, I ended up scraping the game logic.  Instead, the project has a narrative arc and the fun is learning about the characters and locations.

When I had the scaffolding for a mock-up of the game done, I exported a copy of the file for publishing.  Twine creates a single *.html file that contains the entire game sans any media assets.  I tried to publish the Twine project on this CUNY Commons site.  Sadly, I discovered that for security reasons the Commons does not allow us to upload complete *.html files.  I spent a day trying to force a WordPress theme to accept the CSS code from the Twine file, but there was no joy.  My solution was to upload the Twine to my own server and to continue to host the other digital assets used in the Twine here on this Commons site.  I did this in part because the links were already coded in the game, and because WordPress has a superior asset management system.

Argumentation

If you conceive of a game as a series of steps, I found that the program allowed players to go from step (or passage) one to step two, and from step two to step three, but sometimes not from step three back to step one.  Why the program allows it sometimes but not other times is not clear.  Originally, I thought I would control the game around locations like the Tombs, but I found that beginning with the characters gave more linear movement to the new game-play and, if the player hadn’t read the story, might create less confusion.

Each character featured has its own page and their description is taking directly from the text.  I then added an image that complimented the character and some background information that may help to explain their situation.  For example, the office boy is only twelve years old and works full time.  Their character page includes some history of how typical child labor was in the 1800s.   A similar device is used for the locations.  I chose not to include Bartleby as a character, in part because I wanted to maintain some of the mystery surrounding him.  If someone stumbles on this game, perhaps it will inspire them to read the story!

Twine story passages and connections.

Audience

My primary audience was myself.  I wanted to see what I could do with the software and story.  But, since this was a school project, I was also thinking about my professor and my classmates.  However, I could see this being used as a teaching tool for young people reading the story for the first time.

Reflectiveness

When I was reading the story, I made notes of all the words and situations I didn’t understand.  Then, I did research to figure them out.  For example, I didn’t know Spitzenbergs were a kind of apple, native to New York State and very popular at the time.  Or that the murder of Adams by Colt was an actual event.  [I could not figure out a way to get those details into the game, but if you are interested, do read Harold Schechte’s article “The Colt-Adams Affair, 1841” in the Yale Review, which chronicles the scandal.]   As I went through that process, I was reminded of Johanna Drucker’s council that “rather than think about simulating the way a book looks, we might consider extending the ways a book works as we shift into digital instruments” (Drucker).  Much of the fun in reading a story like Bartleby is understanding it within the context of its time.

Works Cited

Allred, Jeffrey. Final Project. 29 Oct. 2020, allred720fa20.commons.gc.cuny.edu/final-project-ideas/.

“About Twine.” Twine / An Open-Source Tool for Telling Interactive, Nonlinear Stories, twinery.org/.

Drucker, J. (2013). The Virtual Codex from Page Space to E-Space. A Companion to Digital Literary Studies, 216-232. doi:10.1002/9781405177504.ch11

Melville, Herman. “Bartleby, the Scrivener: A Story of Wall-Street by Herman Melville.” Project Gutenberg, 1 Feb. 2004, www.gutenberg.org/ebooks/11231.