RETURN TO BLOG

Proctor Postmortem

Sunday, July 1st 2018


Over the past three months, I created and released three horror games - Proctor, Thermomorph, and Arthur’s Nightmare, the latter of which recently went viral. This post is a postmortem for Proctor, the first of those games.

Table of Contents

  • Inspiration
  • Gameplay
  • Implementation
  • Results
  • What I Learned from Making Proctor
  • Conclusion
  • Inspiration

    I recently found myself watching videos of the Five Nights at Freddy’s (FNaF) series. At first, I assumed the game was made in Unity, but I quickly realized that FNaF consists entirely of pre-rendered graphics composited onto a cylinder. What impressed me was that, unlike many other pre-rendered games that are simple enough to be created in PowerPoint, FNaF has a simulation of entities that walk between nodes on a graph. I was also impressed by FNaF 4, which ditches security cameras entirely and instead focuses on audio cues to communicate where the monsters are.

    Disclaimer: I currently have yet to play FNaF, though at some point I plan to sit down and play through the whole series.

    With FnaF 4 as an inspiration, I set out to create my own pre-rendered horror game. Taking the theme of “looking left and right,” I settled on gameplay where the player would look left and right in order to cheat on a test.

    Gameplay

    Proctor presents the player with a test of four randomly generated nonsense questions. In order to find the answers to the questions, the player must cheat off the tests of neighboring students. This is complicated by the fact that a robo-proctor walks around the desks - if you try to look when the proctor is to the left or right of you, you are jump-scared and killed. You must use 3D sound (volume and direction) to determine where the proctor is. The debug view of the gameplay demonstrates this setup visually.

    Proctor Debug View: The green dot and line show the player position and orientation. The large red dot shows the proctor. The red circles show the death zones.

    Implementation

    Graphics in Proctor consist of a dynamically rendered test canvas composited onto pre-rendered video and images. Since the game is 2D, I decided to use the Love2D game engine, which has a video module. The graphics were created in Blender and rendered using the Cycles engine. I used tup for managing the rendering and build pipeline. The final release uses Sentry for free error reporting. Here’s a video of an early prototype that has all of the mechanics implemented.

    Projecting Test Canvases

    Getting the test canvases to project onto the 3D view properly was an interesting challenge. At first, I simply exported the x and y screen coordinates of the tests from Blender. In Love2D, I created a mesh with points matching the screen coordinates and applied the test canvas as a texture. However, that did not look right - it turns out interpolating texture coordinates in screen space does not look the same as interpolating coordinates in 3D space. The image below shows what this looks like.

    To fix this, I also exported the z screen coordinate of the tests. This z coordinate was sent into the vertex shader as a vertex attribute. I then applied the interpolation function from this article and used that to index into the texture.

    Budget

    I spent only $4 on Proctor in order to purchase a robot walking sound effect. All the other sound effects and 3D models were available under either public domain or Creative Commons licenses.

    Results

    Almost immediately after posting on Itch.io, people started to play my game! After years of submitting games into black holes, this was a pleasant surprise. Several people even made videos of the game. My favorite video is the one below!

    As of writing, Proctor has 854 views and 390 downloads, which I consider to be excellent given that this was my first horror game!

    What I Learned from Making Proctor

    Jump Scares Should Be ~0.25 Seconds

    Originally, all the jump scares in Proctor were 30 frames (0.5 seconds at 60fps). However, the jump scares felt slow and weren’t really that startling. I halved the length so that the jumpscares were only 15 frames (0.25 seconds) and felt an immediate improvement. I also got positive feedback from playtesters about the faster jumpscares. You can see the slower jumpscares in the prototype video above.

    Don’t Make 3D Audio An Important Part of Gameplay

    Proctor uses 3D audio as an important part of the gameplay - this manifests in both audio direction as well as volume attenuation with distance. After releasing Proctor, I discovered that some headphones seem to be equalizing audio levels, making the difference in audio source distance imperceptible. This makes the game nearly impossible. Because of this, I will probably never again make 3D audio such an important part of the gameplay.

    Horror Games Shouldn’t Have Permanent Safe Spots

    A big flaw in Proctor is that you don’t actually have to do anything. You can always just stare at your own test, which removes some of the fear and tension that’s present in games like FNaF. The player in Proctor has too much agency - they can decide when to take a risk, whereas in other games the monster has the agency.

    This gives the player time to compose themselves, which detracts from the feelings of anxiety and fear that I want people to feel. In the future, I’ll try to make safe spots timed in some way, or to eliminate safe spots entirely.

    I wonder if run-and-hide style horror games like Amnesia would be scarier if closets were “timed” in some fashion?

    Itch.io Has Organic Discovery

    Most games that I have made have been released into a black hole. In the past, I have even paid to advertise my games with very little success. Itch.io, however, actually has organic discovery. Many people look at the newest and newest/horror pages. If I had known this, I would have probably spent more time making sure my Itch page was properly formatted before release. I would have sent some builds to playtesters using Dropbox instead of just uploading early versions to Itch.

    Once your game gets enough views from the “recently added” section, it starts to appear on the main page, which is ranked by “popularity.” The initial period after release is crucial to getting onto the popular page, and you should time Twitter/Reddit postings to happen immediately after the release on Itch. That way clicks from each of these sources can add together in order to put you on the popular section. Games that get onto the popular section tend to stay there for quite some time.

    Horror Games Have a Large Audience

    I knew there was a large audience for horror games, but I simply didn’t realize the scale. There is a significant audience that looks for new games off of Itch and GameJolt’s horror categories. Many of my early views for Proctor came from newest/horror.

    Small YouTubers Scan Newest/Horror for Games to Do Videos On

    About a day after release, people started sharing videos of themselves playing the game through the Itch comments. Many of these videos are actually well produced, with a high-quality facecam and high-quality game footage - several of these YouTubers are clearly looking to make YouTube a part-time or full-time job. I liked watching these videos - it’s especially gratifying to see the humor in the intro voiceover land. In particular, the proctor has an “alerted” state where he starts running towards you - I found the reactions to this to be absolutely hilarious. However, I cringe whenever I see people get stuck on mechanics that I failed to explain properly.

    One thing to note is that these videos didn’t necessarily drive traffic to the Itch.io page, as I only saw a few clicks coming in from YouTube. I’ve collected the videos in a playlist below.

    Be Explicit About Mechanics

    Controls in Proctor are shown through transparent context-sensitive keyboard prompts. While implementing this, I thought I was being smart by conveying mechanics in a subtle way. However, this was a mistake. Many people missed that you are able to turn the pages of your neighbors’ tests. An explicit text hint somewhere would have gone a long way to making the game more understandable.

    Introduce Mechanics Incrementally

    Proctor introduces a lot of mechanics all at once. If I could redo Proctor, I would probably split the current set of mechanics across two “tests.” In the first level, you only have two questions on your test, and each of your neighbors only has one question on their desk, thus you do not need to flip their pages. Then, in the second test, more questions are added to your neighbors’ tests, thus you have to flip through them to find the answers to your own questions.

    You Always Underestimate the Difficulty of Your Own Game

    When releasing Proctor, I honestly thought the game would be too easy. In reality, many people found the game to be quite difficult even once they had learned the mechanics. It’s incredibly difficult to put yourself in the shoes of a new player. Going forward, I plan to err on the side of making my game too easy, rather than making the game too hard.

    Having multiple levels can help this problem - you probably want to make the first level dead-simple such that everybody will beat it on their first try. With each level, the player will begin to understand the game better and later levels can start to pose a challenge.

    Love2D is Not The Best Tool for Making FMV Games

    I used Love2D for creating Proctor. Love2D is my favorite game engine, but it isn’t the best tool for making pre-rendered FMV games for a few reasons. First, videos must be in the Ogg Theora format. Theora has a poor compression ratio compared to modern formats, and has poor playback performance. Furthermore the Love2D video module has a few significant bugs, one of which can lock up the entire application. I think that Love2D should switch to WebM, which is a modern patent-unencumbered format with a good compression ratio. WebM also supports transparent video which would be useful for these kinds of games.

    Conclusion

    Given that Proctor was my first horror game, I consider it to be a success. I learned a few game design lessons and came away with some ideas for new horror games. One of those ideas was developed into Thermomorph.

    #game-dev #game-design #postmortem

    Similar Posts