Looking back at the lessons learned when designing rules for the competitive typing game "Typefighters".
When I first heard about Typing of the Dead, I immediately fell in love with the typing mechanic. Although it sounds a little bit crazy at first, controlling a game by typing words can be really fun to play (at least for me) while also providing direct typing practice. Sadly the idea was not adopted for other games / genres as well and although there are quite a few smaller games out there using similar mechanics, especially on flash portals, I always felt that there is still lots of undiscovered potential when it comes to typing controls.
What I found most astonishing is that there are almost no typing games offering a competitive multiplayer mode. Sure, there is the cooperative mode in Typing of the Dead and you can always try to be faster then the other player, but in the end the goal is still to finish the game together. There are also a few typing competitions, but those felt merely like highscore comparisons without any direct competition inside the game's rules. Instead, I was imagining a competitive typing game where you would face off against a friend, typing as fast as you can with words / attacks flying in both directions. I now this sounds a bit "nerdy", but I thought it to would be very interesting to compare (and also improve) typing speeds that way.
After thinking about this idea repeatedly, I finally started to pursue it myself three years ago. Around this timeÂ StarCraft II had been out for some time, with the editor getting lots of attention for allowing modifications ranging from RPGs to racing games. Since designing a typing RTS sounded like an interesting design challenge and because I was also interested in finding out how easy it would be to change core aspects of the game using the editor I started the development of a StarCraft II-mod I called "TypeCraft". As I am much more a programmer than an artist having models for units etc. readily available was also a huge benefit.
Development started on a high note since it took only a few hours to build the basic typing mechanics even though I had never used the editor before. I could spawn units having randomly selected words above their heads, the player could select any of them as a target by typing the first character, typing progress was shown by changing the color of the characters already typed and completing the word killed the unit. Designing rules for competitive RTS-gameplay using typing mechanics seemed also easy at first.
Selecting typing targets by typing the first character immediately limits the number of potential targets to 26, maybe 52 if it is case-sensitive. Having that many words on the screen however can easily confuse players, so a concept with a limited number of potential actions was needed. The initial design was therefore inspired by lane defense games. Players could build units by typing words from a build menu, which then start to walk towards the other players base. The other player could try to destroy them by typing the same word again before they had reached the base. Stronger units had longer words assigned to them, which I think was a quite elegant way of modeling construction times (on the attacker's side) and their health (on the defender's side). Later on players had to upgrade their base by typing longer sentences, giving it more health and unlocking more build options.
Balancing this concept proved tricky however. Most games were decided after the first 30 seconds with one player building units as fast as possible with the other one being immediately forced into a defensive role, just trying to survive. Therefore most of the features like upgrading different buildings where never used, removing all strategic decisions from the game. I did a few experiments to mitigate this problem, for example having units attack each other. This decision allowed both players to play offensive, but removed the symmetry of both players typing the same word to counter each other. Adding intermediate control points just prolonged the starting phase, but did not help the balancing on the long run.
This was also the point when I regretted the decision to build a mod, which meant I had to upload it to the BattleNet each time I wanted to test a new iteration and could only use testers owning the game. Having such long prototyping cycles together with the challenges of designing both RTS-mechanics and competitive rules for typing led to the decision to abandon the project after a relatively short time.
The main challenge in designing a competitive typing game is to make it also fun when playing against differently skilled opponents. This does not mean that the better player should be prevented from winning, but that the other one should not feel like being crushed. Instead one should focus on allowing a loosing player to achieve small victories on a regular basis, for example providing them lots of opportunities to feel good for countering a strong attack. Having a fixed game length goes a long way in that regard, not ending the game after a few mistakes but instead giving the loosing player more chances to do it right next time. Individual statistics at the end help as well, since players can set their own goals (e.g. in increase their typing precision) and can see both their individual improvements after a few matches as well as assess whether they are closing the gap to the other player.
Building on the experiences with TypeCraft I knew that pursuing the idea of a competitive typing game further would require some kind of rapid prototyping environment allowing me to quickly iterate on game modes. It would have to work on a very abstract level with a relatively simple presentation in order be completely open in regards to game mechanics and genre. The idea was then to build a number of different game modes that require not only typing speed, but also other skills like tactical thinking or quick reaction times. That way, being good at the other skills could help to mitigate the speed differences when playing against a faster player.
As such I dedicated a weekend to build such a prototype with some game modes to test in the spirit of a game jam. In a way I failed completely at that, using the weekend to build a robust framework for the Unity engine. That meant I had a working typing mechanic, word management, multiplayer setup and all relevant GUI elements. The framework also had an interface which would allow me to easily integrate different game modes later on, providing functions to generate words, move them across the screen, react to players completing them and so on. But aside from a simple test mode with three random words to type that would respawn once collected, I had not build a number of playable modes to iterate on. In hindsight however building the framework first was a good decision since it saved me from rewriting the code later on and also got me into a mental space where I would write down lots of ideas for game modes based on the framework elements I implemented at that time.
After that the first thing I did was extend this basic mode to a 3x3 grid where words of different length would be spawned. Every completed word would count as a point and then be replaced by a different one. This simple mode already allowed some interesting player tactics, as I discovered when playing it myself or observing other players. Some players would scan the grid to find the shortest word available while others would just focus on one position and type the words appearing there as fast as possible (adding a short respawn delay discouraged them though). There were also players trying to steal the word the other one was currently typing (since the words disappeared as the first player completed them) and others that would just ignore or even actively avoid the words their opponent was typing. Making these observations while also receiving lots of encouraging feedback was also a huge motivational factor, as it showed the potential of the game.
Using the observations from the prototypical mode I could now continue to design the first "real" game modes:
Stream: In order to add a sense of urgency compared to the prototype mode the words are not arranged in a static grid, but scroll by horizontally. Therefore, a word must be completed before leaving the screen, preventing players from focusing on one position while automatically discarding unattractive (i.e. perceived as too difficult) words. The mode mostly rewards raw typing speed, but allows different target selection strategies. Direct competition (stealing words the other player is currently typing) is optional.
Projectiles: This mode is similar to the ideas explored in TypeCraft. Players can open an input field at any time to "shoot" a word in the direction of their opponent (i.e. the upper end of the screen). If the word is not destroyed (typed again by the defender) along the way a point is scored. But in contrast to TypeCraft the players can input any word they want, setting the challenge for their opponent. Words are validated of course in order to prevent players from just "banging on the keyboard". These mechanics create interesting dynamics since longer and more complicated words are harder to create, but also harder to block. Players must also decide tactically when to attack and when to defend, while coming up with words to type encourages creativity. Tests showed that this mode showcases the direct competition against another player very well.
Lines: I also wanted to add a mode that represents a very abstract strategy game, revisiting the control point idea that came up with TypeCraft. Just capturing points that were placed somewhere on the screen wouldn't have been much different from collecting the words, so I decided that the spatial relationship of the points should matter somehow (i.e. it becomes relevant which points to capture). Tic-tac-toe provides that with rules which are easy to understand, so the lines mode is based on that general idea. In a 5x5 grid players strive to complete any row before the other one does. After completing the word attached to a grid space the corresponding field is captured by this player. But instead of being turn-based like the original, capturing happens simultaneously and in realtime, so fast typing allows the players to capture fields more quickly. And although words are removed after completion, a new word is generated allowing the other player to steal the field again. Both of these modifications combined with the larger field size results in a quite frantic experience while also preventing draws. Therefore, being good at this mode does not only require fast typing and being attentive on what the other player is doing, but also tactical decisions on which fields to capture.
Again, I tested these modes with a few players, iterating on some of their parameters like word movement speed or respawn delay. I also noted aspects that where received well or other that showed untapped potential and then designed new modes to elaborate on those.
Tug: When testing the stream mode a few players ignored each other as much as possible, choosing different words each. This did not allow direct competition on specific words. But if players did choose the same word the all or nothing approach of counting only the first player that completed the word made it irrelevant how big the difference in completion time really was. Therefore, I wanted a mode that had only a single target for both players and on which the exact difference in completion time mattered. To visualize this the word is attached to a horizontal line. Once the first player completes the word this line starts to move vertically towards the other players end of the screen. It stops once the other player completed the word too and a new word is generated while the line keeps its position. A point is only scored once the line reaches the opponent's end of the screen, after which it is reset to the center again. That way smaller time differences accumulate while momentary mistakes can be canceled out on the long run. Compared to the other modes this one takes a much longer time when played for a score limit, so endurance is one of the key skills here. To end a round eventually the lines speed increases over time. After a few iterations I noticed that a fixed respawn delay (3s) caused players to momentarily calm down during this time, so introducing a random delay (1s-5s) kept things fresh by rewarding continuous attention.
Attention: This mode also originated from the same observations that lead to Tug, but in the complete opposite direction. It also shows only one word at a time, but keeps the all-or-nothing nature of giving only points to the first player to complete it. Again the respawn delay is random, but so is the screen position requiring lots of attention and quick reaction time. Combining all this factors this mode is the most "brutal" one, where a skilled player can completely dominate the other one.
Reflect: Tug created interesting "ping pong"-situations where the line would bounce up and down between the players. This led to the idea of combining this back and forth with the ability to set your opponents challenge by typing harder words at is done in Projectiles. Again, there is a line, but gameplay itself is turn-based. After deciding which player starts the game the line moves towards him / her with an input field attached to it. The player then has time to think about a word as a challenge for the opponent. After the word is written the line changes its direction. Then the other player has to remove this word first and replace it with another one in order to change directions again. A point is scored when the line reaches the end of the screen, adding a risk-reward-element (typing a longer word may take to long, but if done successfully the other player has a harder time countering).
Guess: When playing a particular long round of Projectiles against a friend I noticed something interesting. Coming up with new words is not that easy, so we both started looking around and typed the names of objects we where seeing in the room. After having a good laugh about that we started to communicate via these words, asking and answering questions. Suddenly the words where more than just characters to type but had meanings to play with! I then thought about the fact that one might be able to see patterns in the words a particular person is imagining, which then led to a new mode. Here, the players take turns shooting a word into the opponents direction. This word is then accompanied by two random words taken from the dictionary, but only the original word is relevant for stopping the group. So the prime challenge is to imagine a word which cannot be distinguished from the random ones, which is surprisingly hard. Playing these mode therefore allows for some interesting mind-games, with slower typing players being able to compensate that with good intuition. It is also the mode where huge skill differences in typing speed where mostly not recognized at all, with the players just focusing on guessing right while ignoring the score completely - a prime example for players setting their own goals.
Creative: This mode was mainly added for allowing players to practice coming up with valid words. As the modes with free input accept only words validated by the dictionary it is hard for some players to come up with such words under pressure, especially when not using their native language. The mode rewards players for each new word they come up with, with longer words being worth more points. In multiplayer one can often observe players being inspired by the last words their opponent came out with.
It is a tried and true method for typing games to have only words with different starting characters on the screen at any given time so that target acquisition is done by simply typing this character. This can easily be guaranteed when the words are generated by the game, but not when the players come up with their own words. Not accepting words with a duplicate starting char proved to be to confusing, so the input hat to be rewritten in order to support target selection with words indistinguishable by their starting character. I opted for a solution where after typing the first character the player can switch between all candidates using TAB since I wanted the players to always have one target that can be highlighted by the GUI. However, this function is rarely used, as the words are selected according to their order of creation (and the older the word the more "urgent" it is).
I also wanted the menu to be controllable via typing, so menu entries at the same hierarchy layers had to start with different characters. Hence some of the mode names (Lines could not be called Tic-Tac because of Tug)...
Playing the finished game I am quite please with the result. I was able to solve the problem of huge skill differences demoralizing the weaker player in some modes by allowing them to achieve smaller victories (Guess, Stream), but the game has also some modes that where designed to be more brutal (Attention, Lines). Shaping those could only be achieved by having a prototyping framework as well as regular user tests. The variety of modes has payed of quite nicely, as all of the testers called different modes their favorites.
All in all making the game was a very interesting experience and I would surely have liked pursue the concept even further. It must be acknowledged, however that the concept of competitive typing has only niche appeal, so I decided to not bring it into a more complex game.
If you are interested in playing the game that resulted from these experiments, it is freely available from http://www.typefighters.com (windows, linux, mac or in the browser).