Lettuce Climb, Dev Notes, Vol. 1

For the last long while, I’ve been working on a procedurally-generated platformer/climber called Lettuce Climb. In the game, you play as a head of lettuce who is climbing a mountain.

At the beginning, you can only roll. However, as you enter each of three temples, you gain an ability: in the first, jumping; in the second, jumping off walls; in the third, double-jumping in the air.

It has definitely been my most challenging coding game so far. But I think it’s going to be a really great game. I wanted to explain some of the elements that went into it.

For the longest time, I’ve wanted to make a platformer. But my poor drawing abilities limit what kind of characters I can create.

I’ve been making a series of games with the same assets, and I wondered if there was another way that I could combine them.

Let me recap the three previous games.

In Tortoise Trails, my first game, you explore a procedurally-generated map looking for a head of lettuce. There are hidden treehouses, temples, and other secrets.

In 60 Shells, you try and find the tortoise hidden in the woods while a timer ticks down. This seems to have been the most successful of them, as it combined an easy-to-understand mechanic with a very difficult-to-master challenge of pattern recognition.

And in Lettuce Walk, you move a tortoise in L-shaped patterns, like a knight, in order to move around a miniature board, attempting to pick up a head of lettuce and return home. At the end of the game, depending on how you have done, a puzzle is displayed.

On difficulty.

For an indie gamedev who does not have an army of coders and writers producing explorable content, there are only two ways to make a game worth your effort: the first is to procedurally generate the content, and the second is to make the game incredibly difficult.

A difficult game challenges the player and requires more time to complete. A simple game does not challenge the player and can be beaten quickly. If you have a large army of writers and coders, you can make easy games, because you can make them long enough to provide a challenge. However, as an indie developer, difficulty is your firewall against boredom.

60 Shells was a very difficult game. The timing was purposefully designed to push the limits of what was possible. In fact, I offered to donate $0.60 to charity for every person who beat the game. Ultimately, I only had to donate about $100, and it was well worth the publicity that the give-away generated.

But, crucially, the basic mechanic of the game: clicking on a tortoise, partially obscured by trees, was not difficult, in itself. The mechanic should be easy, while the demands made upon the player’s use of the mechanic should be difficult.

Bad games have hard-to-use mechanics: unpredictable jumping, poorly calibrated controls, difficult-to-understand controls, etc.

The second way to increase replay value is through procedurally-generated content.

Procedurally-Generated Content.

The benefits of procedurally-generated content are two-fold. One benefit (already mentioned), is that it is possible to procedurally-generate more content than you could ever create by hand. But there is a second benefit, which I think is even more important.

Procedurally-generated content allows for exploration and surprise. In a game whose levels are clearly mapped out, there can be no true exploration, because it is always possible for the player to Google the map or ask a friend. Even if they do explore it the first time, they will soon run out of new areas to see and will only be revisiting old ones.

The major deficit of procedurally-generated content is that it is, frankly speaking, not as good as hand-created content. This is undoubtedly true. The ability of a creator to particularly craft the world far outpaces the world he could probably program a computer to create.

On storytelling in games.

One of the things that bothers me about most games is their poor storytelling. I think that games generally suffer from an inability to unite mechanic with theme. You make a shooting game that’s about pacifism, for example. But this is impossible, because all you can do in a shooting game is shoot.

Lettuce Walk tells a simple, thematic story about climbing, life, death, and belief. I don’t want to tell you too much of the story. But it is told through three basic methods.

The first is through text that appears inside the temples, written in the black space, not a diegetic part of the world but presented for the player. Other than those sentences and the title of the game, there is no text in Lettuce Climb. This is to preserve its central aesthetic.

The second is through the climbing mechanic and its consequences: this is a story of a head of lettuce rolling, jumping, and bouncing up a mountain. During this, the lettuce will periodically miss a platform and fall back down a long way. This is undoubtedly a frustrating experience (hopefully, at least: see “On difficulty”), but it will also make the ultimate reward much sweeter.

The third is through sound design. When you start the game, you are at the bottom of the mountain, and you hear the birds chirping in the trees. As you go up the mountain, you see fewer trees (because they can only be placed on tiles that are not blocked from the sky), and you hear fewer birds.

The sound of the birds slowly fades away until you hear just a soft wind. That wind, itself, turns darker and creepier, until, eventually, it fades into a choir, singing a holy song. This is the song you hear as you enter the cave at the top of the mountain and find…

Well, you’ll see.

On Sound Design.

Sound is crucially important to good game design. Your sounds should fit your theme. If you have a game set inside an arcade cabinet, you should have 8-bit sounds. If you have a war game, you might need gunfire.mp3s.

In the case of Lettuce Climb, I again wanted to reuse the musical assets from Tortoise Trails/60 Shells/Lettuce Walk.

When you jump, you hear a low note. When you bounce off a wall, the pitch goes up a bit. By chaining bounces, you can play up a scale until the notes get high and thin. This encourages the player to chain these bounces, as they are musically rewarded for doing so.

In addition, the sounds of the birds were purchased on an audio site (for like $3), the wind was found in Final Cut Pro X, and the choir was made in GarageBand. Sometimes, the simplest and the easiest tools are the ones you have to use.

Sound Design is easily overlooked because you might be listening to music when you play the game, but you have to remember, when making video games, the player is only engaged by two senses: sight and sound. It is really insane to ignore half of the senses when designing a game.

On juicing.

Of course, it’s common to talk about juicing now, which is when you add particle effects, shaking effects, etc., to a game: superficial quirks that make it more engaging but don’t affect the actual gameplay. This is great. However, in Lettuce Climb, often I introduced new elements and found that they took away from the simplicity of the game.

It’s important to always think about the central mechanic, the central theme, and the central aesthetic. I will write another post about those three things soon. Right now, I just wanted to get all that out of me so that I could go to sleep.

The Killer Party Killstarter

My friend Amin and I have written a horror-comedy musical and now we’re trying to film it as a webseries. Check out our Kickstarter video:

It’s about a killer graduation party thrown by a group of college seniors. It’s also about a masked killer who wants to kill that party, and everyone in attendance.

If you like the video, please check out the Kickstarter page and consider donating.

The Is/Ought Gap

I made this game to illustrate Hume’s “Is/Ought Problem,” which basically says that there is no way for the reason to connect a statement about how the world is to a statement about how the world should be. There is a fundamentally uncrossable gap between what is and what ought to be.

 

I made this game for the Game Praxis competition while reading Alien Phenomenology, which challenges the notion that philosophy can only be done through writing.

This was, then, an attempt to create philosophy through the use of an interactive toy/game. You play a figure who attempts to leap over a gap. With every failed leap, a counter increments your number of tries.

Initially, there was no way to ‘solve’ the game, in keeping with Humean thought, but — and I hesitate to explain myself here, because it sort of runs contrary to the point of doing-philosophy-without-writing, but I am ultimately incapable of not explaining myself — I began to think of a way I could critique Hume’s thought within the game.

Personally, I do not believe that it is impossible to make moral claims through reason. But — like many philosophic “problems” — Hume’s is/ought gap is difficult to cross, and so — like many philosophic “problems — it is therefore ignored. The solution of the game, then, is to turn away from the gap (Hume’s gap).

This is a spoiler, and I apologize for spoiling the game for you. But I wanted to think about what this means for Hume (other than, of course, nothing).

Does this game provide a critique of Hume’s statement?

I think it does, in that it provides a way of crossing the gap. However, I doubt that this HTML 5 toy is going to be included in a peer-reviewed journal anytime soon, because — as an interactive toy — it does not meet the criteria of being a written critique.

It writing, this game’s critique feels not only trivial, but off-point. “How do you cross Hume’s is/ought gap?” is the question, but “Walk left” does not seem to suffice as an answer.

Something for me to consider when making subsequent games, or to expound upon, or to otherwise examine.

On the reaction.

This game was easy to code, simple, and fun. I made it in a night and shared it with /r/philosophy. A lot of people focused on “beating it,” and shared how many “tries” it took them to win.

As a game designer, I am typically thrilled when people talk about beating the game. But I felt, in this case, a little disappointed that I had made it this easy.

Hume’s problem is a really interesting one to me, and I wanted to convey some degree of that interest. I wanted the game to reflect the problem, and by making it easy (or too easy), I feel like I undercut the nature of the problem itself, so that my answer felt more like hand-waving (“Nah, just think outside the box!”), than it did a legitimate critique.

But, more complicated answers (invisible platforms, weird jump patterns, etc.) might further conflate the point: “Oh, Hume’s problem can be circumvented by doing a bunch of a weird philosophic gymnastics.” I don’t feel like that’s much of an answer either.

Maybe the answer is simply to make the walk take a lot longer. And — perhaps — if you walk left for a minute, you appear on the other side. But, if at any point you turn right, you immediately pop back out on the left side of the gap.

This — I think — might better convey the philosophic critique: You must turn away from the problem completely to address it. If you turn back, even for an instant, it is there.

But I’m not sure if I’m going to implement that right away. I feel like the worst moment to revise a game is the moment it’s released. Better to take those feelings of incompleteness, of imperfection, and apply them to the construction of the next game.

What’s next?

While I’m working on a couple of non-philosophic games (or, rather, games not specifically focused on addressing philosophic problems), I am very interested in making more philosophic games, for a couple of reasons.

Obviously, it’s fun to feel like you’re engaging with important figures in the history of Western thought. Making this game felt like I was doing something important, even if it’s ultimately an HTML 5 toy.

Secondly, it was quick and easy. I didn’t need to worry about gameplay questions, or how to make it fun, how to make decisions have meaning, etc. Because the game is secondary to the philosophic statement, which reminds me of this Mamet book I just read called “Theatre,” where he lambasts theatrical pretensions, specifically (1) acting methods, (2) directorial aspirations, and (3) theater that is designed to improve people.

To Mamet, theater is only supposed to entertain. Everything else is unnecessary. A play must entertain, and if it entertains, it’s successful. If it doesn’t entertain, it’s a failure.

I think — to some degree — he is right. If you can’t entertain people (whatever that means), and get them to come out, then you can’t have a play, because a play requires an audience.

But, more importantly, I think that all art has — as its primary function — the goal of filling an unknown need, of making a statement, or of otherwise inspiring an audience. Art that does not inspire is pornography, and I feel Mamet’s injunction that the theater entertain (and entertain only) can be refuted simply by asking him if — therefore — a strip club is the greatest theater.I disagree.

Thanksgiving Turkey Simulator

I decided to make a Twine game for Thanksgiving. Here is a screenshot from it:

turkey

It’s going to tell the story of a turkey on the eve of the first Thanksgiving. Basically, his girlfriend gets killed by pilgrims and he leads other turkeys on an all-out war against them, driving their Mayflower out into the ocean, where they all drown. American History is forever changed.

I wanted to sort of invert the story of Thanksgiving as a positive thing, but I didn’t want to write something serious. This story gets a little sexual, a lot violent, and a bit blasphemous.

Your main antagonist is Miles Standish.

Miles was a pilgrim who fought a war against some local Native Americans. He was a bastard, and once, he called a truce and met with two Native American leaders for peace talks. When the leaders arrived, he locked the doors and stabbed them both to death. The local population fled after this, and relations with the pilgrims didn’t get better until, well, ever.

 

A Booklet

I wanted to make a digital guide booklet to “sell,” along with the source-code, under a pay-what-you-want system to accompany the release of Lettuce Walk.

Here is the title page:

lettuceguide-cover

I want to create a small, fun to flip through booklet that would include a collection of short descriptions of the different elements of the game, tips disguised as stories, and a couple of secret ideas that I included in the game to make it fun.

I hope that this is a fun way to implement a free-to-play system, and I hope others enjoy it.

Upgraded Graphics!

This post is going to talk very briefly about the improvements I made to the basic graphics of the Third Tortoise Game, as opposed to the first two.

(The first two tortoise games I made were Tortoise Trails and Sixty Shells. With the exception of a really bad flash game I made in high school, they were the first non-text games I ever made, and it shows.)

So, when I began making my third game — Lettuce Walk, an interactive procedurally-designed puzzle game — I wanted to improve the graphics. However, since I lack artistic and Photoshop skills, I needed to think of easy ways to do it.

This was how they looked when I started:

t3-1

And this was how it looked after the improvements I made:

t3-2

I think this is a huge improvement. What did I do?

I found a picture of a rock on the Internet. I imported the rock into GIMP (a free Photoshop clone). I cranked up the brightness so that it was almost totally white, and then I made everything that wasn’t white transparent.

Then, I overlaid this rock mask on top of the game board, creating the appearance of a well-worn game board.

Then, I replaced the solid-black tortoise icon with a tortoise icon filled in with a picture of obsidian. Additionally, I added a small animation when you pick up the lettuce. Here’s a still of it:

t3-3

Basically, when your tortoise lands on a head of lettuce, it explodes in a burst of green leaves. Even though this doesn’t change or improve the mechanics of the game in any way, I think it makes it more visually stimulating and fun to play.

I hope people will enjoy the game when it finally is released (hopefully sometime this month).

Killer Party Musical

Today, Amin and I launched the website for Killer Party.

kp-facebook

What is Killer Party?

Killer Party is a horror-comedy musical for the Internet in 13 pieces. Amin and I have been working on it for two years now, and it’s finally at the point where we feel like we can share it with others and not be embarrassed.

It is about a group of college undergrads on the cusp of graduation, about to go out and face the world for the first time. But before they leave school forever, they want to do one last thing: throw a killer party.

But when the metaphorical killer party turns literally deadly, they are forced to confront the threat and fight against it. Or die trying.

But what is it really?

Killer Party combines several things that Amin and I really like:

– Horror-comedies
– Musicals
– Webserieses
– Whodunnits
– The college experience
– Parties

For now, I’d like to focus on Whodunnits, and why I love them.

I love Whodunnits because they are games. Because they challenge the mind. Because they require you to puzzle something out in your head. Because — to function — they require an audience response, and a particular kind of response: an analytic one.

A Whodunnit can be more interactive than a game. It can challenge your mind in ways that a game never can. It allows the audience to become a participant in the media. It makes them perform a kind of textual analysis, attempting to derive the meaning from a work.

But there’s a consequence of this:

Whodunnits, like puzzles, lose appeal when they are solved.

How do you make a Whodunnit with replay value?

Part of this is making it function on other levels: rather than just being about a mystery, rather than have the emotional core of the story be a question that the climax answers, the emotion of the film has to come from other concerns.

In Killer Party, it comes from the variety of interpersonal conflicts between and amongst the characters. Because, while the Killer can be revealed, there’s no real answer we can provide to the question of “What to do after you graduate?”

And the question of whether life is all just one big party — whether it is and whether it should be — is not something that can be solved by a resolution.

You can’t debate the reveal of a Whodunnit. Once the killer is revealed, you can’t say, “Oh, but I still think it’s so-and-so.” It’s no So-and-so.

But the answers to more important thematic questions can be endlessly debated, endlessly argued, endlessly puzzled over.

So it’s important — when you’re creating a Whodunnit — to remember that the real mysteries are more fundamental: What does it all mean? What should we do about it? How?

These are questions you can’t answer by pulling off a mask, and they’re the real replay value.

If you would like to request an invitation to our Killer Party (and therefore subscribe to our newsletter), please visit KillerPartyMusical.com. Anyone who subscribes before Halloween will get four demo songs in their email inbox. You’ll like them. I promise. And if you don’t, you can kill me.

Lettuce Walk: Theory, Tests, and Balance

For the last couple of months, I have been working part-time on a game called “Lettuce Walk,” which is stylized “lettuce walk” in keeping with the all-lowercase kōan aesthetic.

t3-2

Lettuce Walk is based on the concept of the Knight’s Tour, a chess puzzle in which a player attempts to land on every space of a chess board.

A knight, if you don’t know, moves in a particular L-shape, so this is a puzzle that can be exceedingly difficult to initially visualize. The L-shapes work together in strange ways, and it takes awhile to get a hang of it.

I thought that a program which procedurally generates these puzzles might be an interesting way to create a diverse variety of puzzles which were all solvable. From a game design perspective, this solves the biggest problem with puzzles, which is, namely:

Once you solve a puzzle, it’s boring.

I figured that the ability to generate a large variety of potential Knight’s Tour puzzles would allow for a puzzle-game with a lot of replay-value, because every time you play, while the basic structure of the puzzle is the same, the actual puzzle presented is different.

knighttour

More about the Knight’s Tour:

There are two versions of the Knight’s Tour puzzle, or at least of solutions to it: one where you try to end on the same place you started, called an “open” solution, and one where you end somewhere else, called a “closed” solution.

Lettuce Walk mimics a closed Knight’s Tour. The player is supposed to move their tortoise in L-shaped patterns around the board, picking up a lettuce, and returning home.

However, this can be a very difficult puzzle. It is very difficult for someone to quickly pick up the conceptual skills (or patience) needed to solve a Knight’s Tour. So I needed a way to make it easier for people to start playing the game.

Therefore, the moment the player lands on the lettuce, the tortoise may return home. This allows you to complete each level with a much easier solution. Consider this like using all your Angry Birds to pop the Bad Piggies. Sure, you get to move onto the next level, but you didn’t really beat it.

A Brief Detour: The Curse of Minimalism

Like the two previous tortoise games (Tortoise Trails and Sixty Shells), I wanted to minimize instructions.

I really hate reading instructions in games I play. Not that they are all bad or anything, and obviously you need instructions (or a tutorial) in some games. But, ideally, the game will be so self-evident that you will not need instructions.

Without instructions, how can someone play?

Well, you have to make sure that the game has three qualities: (1) controls are intuitive, (2) the game is responsive to player input, and (3) the consequences for new failure are small.

(These are just three concepts off the top of my head, and are not intended to be comprehensive — or, as they sometimes say, “necessary and sufficient.”)

1. Controls are Intuitive

This has been fairly easy, for the most part. The game begins with a single command: “pick up the tortoise.” Most people who test the game seem to understand how to do this intuitively.

They click on the tortoise, and it picks up the little guy and sets him down. They click on him and hold him, and two other squares flash green. People usually spend a couple clicks trying to figure out the next step, which is that you can set the tortoise down on any green square.

2. The Game is Responsive to Player Input

When a player picks up the tortoise, green squares flash on every place that the tortoise can move. When the player lands on a square, it plays a note and a burst of green leaves fall from where the lettuce used to be. When the player lands on the lettuce, it rings a bell. When they return home, it plays a chord.

Here is a fantastic video on juicing, which I think is a must-watch for game developers. The basic concept is that increasing game responsiveness to players (adding literal bells and whistles) creates an immersive quality in a game that transforms the experience.

3. The Consequences for Failure are Small

If a player is not explained what a bad move is, and then they make a bad move unknowingly and are punished drastically for it, they will resent the game.

Therefore, the game developer has two decisions they can make: (1) Describe the basic strategy of the entire game before play, or (2) Make the consequences for failure — or at least initial failure — very small.

In Lettuce Walk, when a player makes a bad move, they must start over. This consequence is disastrous. However, the consequences for attempting to make illegal moves is very small (it just moves the piece back to the square it was on), and this is the most likely form of “bad moves.” Once a player understands the basic movement mechanic, he or she is unlikely to make unknown bad moves: a move that they thought was good might reveal itself — later — to be bad, but that is a natural element of the gameplay, like making a bad opening in chess, or taking out the bottom blocks in Jenga.

However!

I still don’t think that Lettuce Walk is intuitive enough. While the movement mechanic seems easy enough to grasp, I don’t think a lot of people understood the concept of getting the lettuce and returning home, and when they did, they almost never understood the premium placed on landing on every square.

The first solution I developed for this was to implement a scoring system that gave you bonuses for certain behaviors. For example, picking up the lettuce gave you a x7 score multiplier, which encouraged the player to postpone picking up the lettuce for as long as possible, landing on as many spaces as they could.

Also, landing on every single square before you returned gave you a +777 score bonus, in many cases more than doubling your total score. I thought that this would be plenty of information for people to deduce the ultimate goals of the game, but I was wrong.

Some people did not notice the numbers. Others were confused by them. In the absence of a “score” label, people did not understand what they were for, and they certainly weren’t motivated to action by the numerical adjustments.

So I implemented a new “scoring system.” When you complete a level by landing on every space, you receive a green head of lettuce at the bottom of the map. When you complete a level imperfectly, you receive a red head of lettuce (referred to in the javascript as “cabbage”). I think people are conditioned that green is good and red is bad, so I hope this is more effective didactic measure.

And Finally…

When you complete a game of Lettuce Walk, a poem is displayed. There are 8 levels in the game, and there are 8 lines in the poem. For every level that you complete perfectly, you get a green line of poetry that tells a positive story. For every level that you complete imperfectly, you get a red line of poetry that tells a negative story. If you lose in a level, that corresponds to the final line of poetry, something like a full-stop.

The poem is about the love of the tortoises. If you complete every level perfectly, then I think it’s a really sweet love poem. If you complete every level imperfectly, I think it’s a pretty sad love poem. But if you complete — as most people will — a mix of perfect and imperfect levels, then the poem is a mix of red and green, positive and negative, happiness and sadness.

I really enjoy this element of random art generation, and I hope others do, too. Writing poetry is a dead art — many say — but I could not agree less. Hopefully, by integrating poetry into games (which no one argues are dead, but many argue aren’t art), I will be able to make poetry more relevant, and games more artful. At least in some small way.

However, since I never specifically spell out what the poem is for, or its relationship to the rest of the game, I am still struggling to devise a way for the player to understand its importance.

A Few Problems:

– Players understand the basic mechanic, but when they encounter the rock, they do not consider the possibility that they could pick it up. I am considering making this easier by putting a grey square underneath it, signifying that something is unusual about it.

– There is a confusion about the moon. Since I haven’t mentioned the moon at all in this blog post, I guess you have some confusion about the moon, as well.

– Early levels are too easy, and later levels are too hard. But that’s not the full nature of the problem. However, it leads easily into my final section:

Balancing Act

The early levels of Lettuce Walk are almost impossible to lose. Well, that’s not true. Sometimes they generate levels which are literally impossible to lose: you walk through a linear path and end at the beginning, happily, with a green head of lettuce to show for it. Other levels let the player make one or two choices: sometimes, these end in failure, but more often, they end in imperfect completion, and therefore, a red lettuce.

By the end, however, the map is almost empty. This has two consequences: (1) It makes it almost impossible to get the green head of lettuce by landing on every space without dedicated pre-planning, and (2) It makes it way too easy to finish the level imperfectly.

This is my big balancing problem: I need to discover a way to make the levels harder to beat imperfectly, and easier to beat perfectly. It seems that there is a kind of equilibrium somewhere in the middle: there are enough choices to make the level loseable, but not enough free space to make it too easy to win.

This comes to an issue of balancing. How can I let the game land in that sweet spot between being too difficult and being too easy? I think I am going to make the first half of the game’s levels shorter, making them easier, and cap the ultimate difficulty. I do not want to create a game that requires graph paper to play (though I always love the idea of people really having to think through a game in order to play/understand it fully).

The only way to do this — as far as I can tell — is to implement changes, test them, adjust the changes, test them again, and repeat until good. Here are some things that I added to the game and then removed after testing:

– An undo move button
– An item that allows you to view the perfect solution
– The aforementioned score system (your total score served as the title of the poem, an idea I was infatuated with but which no one understood)

Additionally, the method by which the game generated levels changed. Initially, it randomly placed the trees, and then checked to see if the level could be solved. After a couple failed tests, it would regenerate the levels. This had a number of drawbacks: (1) some levels were trivially easy, (2) it was not guaranteed you could ever land on every space, and () sometimes perfectly solveable levels were rejected because the depth-first algorithm would not solve it in a reasonable length of time (for me, for a web game, a reasonable length of time for the computer to perform this check is instantaneous)

And I’m sure there are others. With Sixty Shells, the iteration became an important part of determining what exactly the game would be: initially, there was a set time limit with the goal to click as many tortoises within this timeframe as possible. Eventually, through testing, it became apparent that the levels escalated in difficulty to a point where they were no longer enjoyable, so I paced the game to reach this threshold around 60, and oriented the game around reaching it.

To solve these difficulties in level generation, I instead re-coded the game so that the game would start with an empty map, “solve” it with the number of steps that that level required, and then place the trees around the map.

This had the advantage of only generating levels that were totally solvable, and allowed me much greater control over the nature of each level, allowing me to place rocks in specific places that did not ruin the game.

But I still have a few other features I need to implement before I launch the game:

– An axe you can pick up and use to cut down one tree.
– A sunflower that spreads when you land on it.
– A special hidden temple level.
– Better effects for the moon transition.
– Better integration of the poem into the level design.

I’ll try to figure those things out for the rest of the week, and I’ll update with another post as soon as I have.

KoanOfTheDay.com, #Zen Kōanunism, and Why You Should Start a Religion

Kōan of the Day (stylized “kōan of the day”) is a project I started about a year ago when I had the idea to reserve the domain name and a friend said it would be a good idea. Since then it has grown remarkably; however, not in views.

In terms of an audience, the reach of kotd is quite small: a few thousand views a day, and a few hundred subscribers.

But it has helped me enormously.

I learned how to keep people’s attention with text in videos to make some of my video kōans. The next week I used those techniques to make #FitchTheHomeless.

I taught myself how to make Twitter bots in order to code an oracle, based on a character in the kōans, and that has since grown to more than a dozen bots with several thousand total followers.

I taught myself PHP and JavaScript to write interactive kōans and text-based games, and now I know the basics of web programming. I made enough small games that a friend asked when I was going to make a “real game” and I made the Tortoise Trails, and Sixty Shells, and now I have three other games in development. (@GunfightGame, the 2004 AIM Conversation Simulator, and Lettuce Walk, the third in the Tortoise Trilogy).

I spun off the writing style to an ethics handbook that I self-published through Reddit and Kickstarter, and I used what I had learned from typography design on the kōan booklets to design the book.

Each of the skills I acquired for the benefit of the kōans I was later able to use for other projects, and without the motivating force of the kōans (and its related religion, #zen kōanunism), I would not have been able to accomplish them. Without koanoftheday.com, I would have either stayed in my comfort zone or not made anything at all.

And this is why I encourage everyone to form a religion. By religion, I mean the sort of philosophy of meaning, by which Hume’s is/ought gap is crossed. If the Münchhausen Trilemma is to be accepted, and I think that it must, then this question is unanswerable except by assertion, and through the assertion of meaning, action can be wrested from knowledge.

(Within the #zen philosophy, the gap is crossed by defining understanding as application, though it conveniently doesn’t ask why anyone should strive for understanding, except to appeal to their own self-interest, or their apparent self-interest.)

And yet by asserting meaning and assuming self-interest, I generate it: the skills developed through the “understanding” of the third law of #zen are applied to other projects and produce the kinds of benefits promised (in jest).

Therefore, this religion — and perhaps any religion — serves as a sort of “leap to faith” that achieves its promises through means of a placebo effect.

Why create a religion? Because I believe that an inevitable consequence of religion is the submission of an individual’s will to another, and I believe that an individual’s artistic impulses should not be sublimated to another’s will. (However, there are those who argue that the very nature of freedom is such a constraint.) Then why would I ask someone to believe in #zen? Well, I don’t: the first law of #zen is “all #zen is a lie.”

@GunfightGame, a Shoot-Out Game for Twitter, Now in Beta

desert_BG

I have been interested in Twitter Bots for a couple of months now. With Jay Weingarten, I designed two bots. The first is called @SMOOTHTALKBOT, and it recommends Santana’s Smooth to people who ask “What’s the best song?” The second is @RegisPhilbot. It is a Weird Twitter recreation of America’s most beloved TV gameshow host from one decade ago.

I should say that we didn’t call it Weird Twitter at the time. But some people have referred to it as that. I think there are similarities.

Both of these bots violate Tiny Subversion’s Basic Twitter Bot Etiquette, in that they contact people without solicitation. But so does @RedScareBot (who TS’s Darius Kazemi calls “such an asshole”). Honestly, I’m not so concerned about the Ethics of Twitter. Does @RegisPhilbot cause harm to others? If you count the annoyance of receiving a weird tweet, then yes. But that harm is so small, and so inconsequential, and it’s counter-balanced by the joy that the Philbot brings to the world.

This perhaps introduces the field of Twitter Bot Apologetics: I am defending my creations, rather than pursuing truth.

Other bots I’ve created that violate these ethical guidelines: @GrootBot, @NotARacistBot, and @NotAFeministBot. The latter two do this only by retweeting with permission. I find the “harm” done by an non-consenting retweet to be so small as to be immeasurable. But it’s still bothered me.

However, there’s a problem.

Twitter Bots don’t really get “discovered” in the same way that a blog post might be. If I post a really good essay, people will share it. But people don’t really “share” Twitter accounts. They just retweet them. And if an account tweets into a void, without ever contacting the outside world, it sort of languishes in this place.

For example, I created @yoimsola.

Every minute, this bot tweets what I lovingly describe as “some LA bullshit.” Basically, celebrity-sightings, not-so-humblebrags, and moments of existential despair. It’s also only following people with the last name Spielberg.

He never tweets at anybody, though (too self-absorbed), so the only people who ever notice him are people who search for celebrity names and then see that he’s claimed to run into them. (People often tweet at the account, asking where these celebrities were sighted. Nowhere on the account does it say it’s a bot, and apparently the 44.5k tweets do not deter them from the belief that it is a Real Human Being.)

So I began to be interested in the idea of a Memetic Bot, that is, a bot whose programmatic structure naturally facilitates its sharing by others. In short:

Could I create a bot whose inherent share-ability was a function of its design?

My first attempt was @TheComplibot.

Every hour, it tweets a compliment to one of its followers. Since it only has 30 followers, pretty much everyone gets a compliment pretty much every day. Follow it and reduce this problem, please.

Though I believe in the inherent structure of @TheCompliBot, it hasn’t really panned out. People retweet @TheCompliBot, but it doesn’t seem to inherently spread itself. (Perhaps that is because it prefixes every tweet with “Hey” and thus shows up too often on people’s timelines? Maybe I should change that. Anyway, I’m getting off-topic. But one last off-topic thing: I’m thinking about making @TheInsultBot. I don’t know why, but I get the feeling that people will enjoy being mocked more than they enjoy being complimented.)

In addition to this drive — the Creation of a Memetic Bot — I’ve been wanting to make a Twitter Game for some time now. And I just haven’t had any good ideas. Some kind of Twitter Bot scavenger hunt? (“Find a tweet that references Obama and cream cheese.”) Maybe a game where you are assigned a phrase to convince another Twitter user to say.

But then I had an idea…

I am a huge fan of Westerns. That’s why I made a series of YouTube shorts with Doug Patterson called “Old West.”

What if I could make a Twitter Bot that would facilitate two people on Twitter having a gunfight? Through its automated procedures, it could facilitate a kind of person-to-person game on Twitter, giving the communications platform the sort of interactive playfulness that face-to-face communication has.

There are a few games on Twitter already, but — as far as I can tell — they are mostly trivia and word puzzles. This makes sense. After all, Twitter is a textual communications platform, so it makes sense that most of the games are textual communications. But I don’t think that has to be the case: I think there is room for a whole bunch of new games on Twitter. And I hope this spurs other ones.

As such, I named it after the first game to ever have a microchip. I hope this connects it to the past, while also opening doors to future games. I also hope that I don’t get sued. (Can I? I don’t think you can own a title. Man, I hope this second-hand legal knowledge is worth relying on…)

With the creation of this game, I had four considerations to take in mind:

1. Not involving people who don’t want to be involved
2. Not allowing other people to misuse the bot in a way that violates 1.
3. Making it fun and entertaining
4. Making it non-violent, or at least non-violent enough that it doesn’t offend bystanders.

Here was how I tackled those four considerations:

1. Not involving people who don’t want to be involved.

I required a duel to be initiated between two people. The first would challenge another by saying “@GunfightGame I challenge @ATwitterUser to a duel.” Then, a tweet would be sent to @ATwitterUser, telling them of the problem and asking if they agreed. If they did, the game would begin.

2. Not allowing other people to misuse the bot in a way that violates 1.

Of course, this being the Internet, I was worried people would take advantage of the challenge mechanism. Even though the bot requires the consent of both parties to proceed, that first message could still be considered spam, and I didn’t want to enable the entire Twitterverse to use my bot as a sort of spam.

So I decided to limit who you could challenge to people who were already following you. This puts the impetus on you. If people don’t like you challenging them, they can stop following you. If they do, you can’t challenge them anymore. I figured that this solved that problem (though I guess we’ll see…).

3. Making it fun and entertaining

Once the second party (the “challengee”) agrees to the fight, another tweet is tweeted that tells both players that a duel has begun, and that the first person who replies “bang” will be victorious. I thought about requiring multiple shots, but I didn’t for three reasons:

i. I didn’t want to have to code it. The bot uses Google App Scripts, and stores no information in a database. Keeping track of multiple shots would require a database (or at least some cleverly structured replies). I didn’t want to bother.

ii. I thought it was more fun for it to just be quick response. The concept of the gunslinger is all about you being quick or dead. And since there’s no way to have users affect the accuracy of their shot, I thought this was the best way to create a sense of meaningful play for both participants. Everyone knows how the game works.

iii. I thought people would be more likely to play the game the less effort it required from them.

With the basic mechanic understood, I then went through and punched up the tweet text itself. I wanted to have a sense of those great Elmore Leonard novels. Quick prose. Declarative sentences (or fragments). I wanted to capture that feeling from the beginning of Once Upon a Time in the West, the heat, the boredom, the tension, and the vast emptiness.

giphy

4. Making it non-violent, or at least non-violent enough that it doesn’t offend bystanders.

Normally, this isn’t a concern of game-makers. In fact, quite often the opposite concern is the case: people want to make their game as violent as possible. I’m not a huge fan of violent games, though. And I wanted to be especially cautious with this one, because it had the possibility of involving people who had not consented to the violence.

With a personal tweet, I can judge whether I think it’s appropriate for the person, the situation, and the time. But the bot can’t have that level of oversight. It needs to be programmatically designed not to be too violent in any circumstance. To accomplish this, I did a couple of things:

i. I made the introductory tweet totally non-specific. Though the name of the account is @GunfightGame, the message simply says that you’ve been challenged to a duel.

ii. Once you play the game, the language is archaic, metaphoric, evocative of violence, but not violent itself. When someone is killed, they are “gunned down.”

iii. The graphics are bright and cartoonish.

@GunfightGame is now in Beta.

If you would like to play the game, you can tweet “@GunfightGame I challenge @SoAndSo to a duel.” (You don’t have to say “to a duel” or “I,” but you do need to say “challenge” and the name of a follower. Otherwise, it rejects it.)

There are still a couple of bugs in the game, and I’m sure there will always be situations in which it malfunctions. Opening yourself to a wide Twitter audience is always going to cause problems. With a browser game, you can control the ways in which an ordinary user interacts with it, what kind of input they provide.

But with @GunfightGame, there’s no controlling that. Anybody on Twitter can tweet anything at it at any time. If it starts to get too many tweets, it will definitely begin to malfunction. People say that you should prepare for success, but there’s really no way to do that. If and when it starts to malfunction, I’ll try to fix it.

For now, I invite you to challenge your followers, and please tweet any bugs or suggests to @GregKarber.

A website is coming soon.