More Twitter Bots

Internet, Programming

Tweets by @EveryBookBot

Since I released @HoroscopeBot earlier this summer, I haven’t stopped thinking about Twitter bots as a creative medium. Corny “I could make a bot for that” ideas kept popping into my thoughts. After reading this appreciation of museum bots, I decided to try my hand at making something similar for a different catalogue.

This led to the creation of @EveryBookBot. Every hour, it takes a random word from Wordnik and tweets a book on that subject from the Google Books API. The goal is to mimic the serendipity of browsing a library or a friend’s bookshelves. Books cover such a delightfully broad range of topics, everything from crackle glass and Spanish fashion to concise philosophy and thumb wrestling. The more obscure subjects fascinate me; who loved this thing enough to write a book about it, and who was their audience?

Tweets by @EveryGameBot

Its sibling @EveryGameBot isn’t quite as diverse, but perhaps that’s to be expected from a younger medium. This bot tweets a random video game or board game every hour, drawing data from the Giant Bomb and Board Game Geek APIs. Highlights so far include a political game from 1894 and an obscure fighting game best remembered for its FF7 tie-in. Exploring old esoteric games feels particularly worthwhile in a culture that’s too often fixated on the new and popular.

On the technical side, both bots resize and tile the book/game covers using a JS ImageMagick library. The cover tiling is done to reach the 440×220 image size that Twitter prefers, though I rather like the aesthetic effect as well. I’m also using a simple PostgreSQL database (which Heroku conveniently provides) to ensure the same item doesn’t get tweeted twice. The source code for both bots is available on Github.

→ No CommentsTags:  ·  · 

Making @HoroscopeBot

Internet, Programming

Tweets by @HoroscopeBot

Last weekend, as a side project, I decided to create an oracle. Like most oracles he spouts nonsense, occasionally happening upon a cogent statement by random chance and serendipity. His name is @HoroscopeBot, and he takes the auspices of Twitter to post a semi-coherent prophecy every twenty minutes.

What inspired this unusual creation? Through another act of internet happenstance, I became acquainted with two prolific bot-makers: Darius Kazemi and Rob Dubbin. As I followed their various projects, I slowly became convinced that bots were more than a mere novelty. Their playfulness with language and meaning was strangely revealing. They were subversive in a world that is increasingly run by algorithms. They could also embrace the inherently unpredictable nature of automation and make it charming.

While ruminating on these bots, I conceived of a simple bot idea of my own. I decided that I needed to make it right away, and devoted an idle weekend to develop the minimum functionality. The idea was to to find tweets of the form “you will ______”. If I prepended two such statements with a zodiac sign, it would create a disjointed horoscope. For instance:

GEMINI ♊: You will come out on the banks of the Rio Grande, but you will have to build a jail.

LIBRA ♎: You will be my queen, but you will NEVER MAKE A FREE THROW IN YOUR LIFE.

SCORPIO ♏: You will understand it, but you will need tissues.

On the technical side, this involved communicating with the Twitter API using OAuth, parsing text with regular expressions, and finding a host that could re-run the logic at set time intervals automatically. Following an online tutorial, I began developing my bot in Google Apps Script.

I initially thought that grabbing tweets would be the most difficult technical hurdle, but the API was actually quite straightforward. The rub was that my application required manual reauthentication every few hours, which is a major annoyance for a program that’s defined by its ability to run 24/7. Twitter has a workaround for this; they will provide you with a single access token that will never expire. However, Google’s OAuth library would not allow me to simply provide it with a token; it wanted to do authentication the “right” way.

To make the bot fully independent, I had to port the logic to Node.js and deploy it on Heroku. This was not a smooth process (mostly due to the limitations of my git knowledge), but the twit library finally enabled me to connect to Twitter indefinitely with my access token. As of Sunday morning, @HoroscopeBot should regularly tweet new prognostications with no further intervention; you can check out the source code on GitHub.

In an interview with the Boston Globe, Darius says he was inspired by Ian Bogost’s idea that, in lieu of writing, objects can embody philosophy. In that context, I’ve thought about what sort of viewpoint my bot is advancing. Maybe it demonstrates the incompleteness of written language. Sentence fragments are fungible, and simple juxtaposition can create unintended meaning; context is always important. Alternately, perhaps it celebrates second-person aspirations. Somebody is saying “you will”, will you?

→ No CommentsTags:  ·  · 

Solo Queue: An Exercise in Serenity

Programming, Video Games

This weekend I committed to finishing a small Twine game I’ve been dabbling with intermittently for the last year. It may seem a little esoteric (and rather silly) if you’re unfamiliar with the game genre being parodied, but hopefully it’ll still convey the general idea.

You can play it directly in your browser by clicking the title below:

Solo Queue: An Exercise in Serenity

Solo Queue is inspired by Dan Bruno’s Time for some Fire Emblem and Alex Austin’s Bioshoot Infinite + 1. I was intrigued by the notion of abstracting a game’s core mechanics into Twine as a form of critique. I wanted to apply the same approach to the lords management game (a.k.a. MOBA) I play most regularly: League of Legends.

While I was fiddling with Twine, I was also working (and eventually had some success) at climbing the season 3 ranked ladder in solo queue. There is a certain inherent insanity in attempting teamwork with four complete strangers. To quote Reservoir Dogs:

Mr. Pink: Why can’t we pick our own colours?

Joe: No way, no way. Tried it once, doesn’t work. You got four guys all fighting over who’s gonna be Mr. Black, but they don’t know each other, so nobody wants to back down. No way. I pick. You’re Mr. Pink.

Succeeding in solo queue requires diplomacy, flexibility and ego management. Ultimately, it’s a lesson in serenity; you must accept that you are going to lose many games regardless of your personal performance or skill.

Solo Queue in Twine

As I’ve indicated previously, I had some troubles working with Twine. In fact, halfway through development I moved the passages to a plain text file and began compiling them directly with twee. I also wanted to avoid mixing JavaScript code with story content, so I stored the macros in separate files and wrote a few quick Perl scripts to append them together at build time. The workflow worked quite well once I’d set all that up; I especially enjoyed being able to easily import Leon Arnott’s excellent Twine macros.

It felt great to work on a hobby game again, though I’d like to attempt something with more systemic mechanics for my next side project. In the meantime, I hope you enjoy my preposterous little game, and to all the League players: best of luck in season 4!

→ 1 CommentTags:  ·  · 

Twine Troubles


Photo by Daniel Schwen

The interactive fiction platform Twine has been around for many years, but recently it’s been at the centre of the DIY game creating movement. Rise of the Videogame Zinesters heralds it as an accessible development tool for those without programming experience. New voices are joining the game-making world, and the variety of Twine games is truly remarkable: personal games, satirical games, Kafkaesque games, sexual games, and many more.

Inspired by the creativity of this new wave of game makers, I decided to work on a small Twine game as a side project. I read a few tutorials, downloaded the application, and began assembling a story. Unfortunately, I started encountering minor hindrances much sooner than expected. I was digging through forums and documentation to implement functionality that I thought would be trivial. Disheartened, I frequently had to resort to kludgy workarounds.

Here are my four biggest frustrations with Twine:

No Nested Logic

Twine has built-in syntax for linking passages, displaying text conditionally and getting/setting variables. However, the syntax does not allow any of these to be nested. You can’t display a variable inside a link or a conditional statement. You also can’t embed any html inside a link, which makes image links difficult.

// Can’t print a variable in a link
[[Hello there <<print $name>>|Say Hello]]

// Can’t conditionally print a variable
<<if $name eq "Bob">>Is <<print $husband>> feeling better?<<endif>>

// Can’t embed an image in a link
[[<html><img src=”foo.jpg” /></html>|Link]]

The workaround is to write your own html in these cases, instead of using the built-in Twine syntax. You can access the Twine variables and link to passages using JavaScript, though that has its own headaches (explained in detail below.)

Verbose Macros

Twine allows you to write custom JavaScript macros, which is great! The process for doing so, however, is a tad obfuscated and verbose. To make a macro: create a new passage, add the tag “script”, then write your logic in a function with the following template:

macros['randomnumber'] = {
    handler: function(place, macroName, params, parser) {
	insertText(place, Math.random());

That’s the bare minimum script for inserting a random number. Here’s a fancy version with all the bells and whistles:

try {
  version.extensions['randomnumber'] = { major:1, minor:0, revision:0 };
  macros['randomnumber'] = {
    handler: function(place, macroName, params, parser) {
	if (params[0] === undefined) params[0] = 0;
	if (params[1] === undefined) params[1] = 1;
	var n = Math.round(Math.random()*params[1] + params[0]);
	insertText(place, n);
} catch(e) {
  throwError(place,"randomnumber error: "+e.message); 

None of it is egregiously verbose, but boilerplate phrases like “handler function place macroName params parser” are daunting. Twine is a great tool for first-time game makers, it would be nice if writing macros was equally approachable.

I also wish it were possible to import script functions from external files. That would allow authors to share and reuse modular components. A library of common functions would be a boon to those without the technical knowledge to write their own JavaScript. Dan Cox has a clever macro for loading external JavaScript libraries, which I’d love to see integrated natively.

File Format

Twine is a graphical interface wrapper for a simple plaintext format (called twee). However, the application saves stories in a .tws file, which is just a Python pickle serialization. Since this format is not human readable, it discourages the use of source control. Why bother tracking your changes when you can’t understand the incremental differences?

Thankfully, there’s an easy built-in way to get around this. In the Twine menu, call File > Export Source Code to export your story to a plaintext twee file. You can even modify that file in a text editor and reimport it back into Twine (though you’ll lose some of your previous passage arrangement).

Weak Documentation

There is some documentation for both Twine and twee. The former covers the basics and the latter alphabetically lists available functions (assuming robust JavaScript knowledge); neither is terribly useful for learning to write macros. I found the answers to my questions scattered across the TweeCode google group, Porpentine’s resource compilation and Dan Cox’s macro tutorials. Here are a few useful tricks I had to figure out the hard way:

Firstly, if you want to link to a passage (named “foo”) from embedded html (e.g. for an image map) use <html><a href="#" onclick="javascript:state.display('foo', this); return false;"> foo </a></html>. (If you neglect to return false, it’ll work on Chrome but not Firefox.)

Secondly, if you set a variable in Twine syntax using <<set $foo = true>>, you can access it from within JavaScript macros with state.history[0].variables["foo"]. You can use this to get around some of the nested logic issues I mentioned earlier.

Finally, a minor idiosyncrasy: Twine does not allow links back to the “Start” passage. Many authors get around this limitation by making a new first passage and displaying it in “Start” with <<display ActualStart>>.

Despite my criticisms, I still think Twine is a valuable and important platform. Fixing certain small issues would simply improve what the tool already does well: provide a accessible way for everyone to make personally meaningful games. Twine is free and open source with a passionate community, so I’m certain it’ll continue to improve and grow.

→ 5 CommentsTags:  ·  · 

The Principles of Programming in SpaceChem

Programming, Video Games

SpaceChem screenshot

SpaceChem is a remarkable puzzle game about fake chemistry. The game challenges you to build a factory in order to transmute the given input molecules into the given output molecules. While chemistry is the theme, on a mechanical level it has more in common with programming. The methods used to tackle challenges in SpaceChem are akin to real techniques used by computer programmers. I’d like to elaborate on these manifold similarities, as well as explore how games like SpaceChem could be used to promote procedural literacy.

The player commands two circular “waldoes” by laying out paths and instructions for them. The waldoes follow the path and sequentially execute any instruction they come across. They can grab, drop, rotate, sync, bond, fuse, request input or dispatch output. The waldo’s analogue in computing is the processor, a hardware component that sequentially executes basic operations defined by machine code. Like processors, waldoes are the engines that drive the control flow of a SpaceChem factory.

When a waldo grabs a molecule, it gains the ability to perform instructions directly on it. In other words, a grabbed element is more readily and rapidly available than one lying elsewhere on the grid. Conceptually this is analogous to storing data in registers, a form of computer memory that is accessed very quickly and that the CPU manipulates directly. Just as a waldo can only grab one molecule at a time, computers have very few registers and must therefore rely on caching.

If grabbed molecules are like data in registers, then molecules left on the grid are cached. The cache is a larger, cheaper form of memory, but it is slower to read and write. Data must be written from the cache to a register in order to be manipulated directly by the CPU. The amount of memory in SpaceChem’s “cache” is governed by the area of the grid (8 x 10). Each coordinate on the grid can therefore be considered a unique memory address. This analogy is enforced mechanically: a factory “crashes” if two atoms collide on the grid, since you can’t store two values in the same memory address.

SpaceChem screenshot

Each factory has two waldoes, and they must be properly coordinated as they move through time and space. This coordination is facilitated by the sync node, which tells a waldo to wait until its twin has also hit a sync node. Parallel waldo management is akin to parallel programming, and they share the same perils: deadlock, starvation, race conditions, etc. The waldoes are like threads operating on shared memory space, and sync nodes are functionally similar to semaphores (operations that tell threads to signal and wait.) Operating two waldoes simultaneously in SpaceChem forces the player to confront the same shared resource problems as parallel computing.

SpaceChem and programming involve similar challenges: laying out simple instructions to achieve a complex result while managing limited time and resources. Like a good software specification, each puzzle is clearly presented as a black box defined only by its inputs and outputs. The player lays out instructions, starts up the factory, observes errors and corrects them, iterating until the puzzle is solved. Solutions can then be further optimized to take less time and use fewer instructions. SpaceChem and programming are engaging, flow-inducing activities because they have an identical inner loop: implementing, debugging and optimizing.

At this year’s GDC, Michael John asserted that programming is 21st century literacy. If computer programming is currently considered esoteric knowledge, it’s because our general education is not preparing students to think about problems in an algorithmic or systematic manner. Ian Bogost calls this procedural literacy: “the ability to reconfigure basic concepts and rules to understand and solve problems.” SpaceChem may not be an ideal game for the classroom (it’s far too difficult, for one), but it strongly suggests that the best way to learn about and engage with complex systems it to play with them.

→ 1 CommentTags:

© 2007-2014 Matthew Gallant, hosted by A Small Orange, powered by Wordpress.