Creating The ‘Game Game’ Level (Devlog 6)

It’s been awhile since my last blog post. Since then, I’ve mainly been working on two things:

  • Getting the game to work across multiple rooms (+ adding functionality to move between them)
  • And adding 40 unique objects to the game (4 item rows; 10 objects per row)

My main goal in working on the level editor has been to make this level: Screen Shot 2016-04-27 at 5.00.32 PM

This is the level from my first prototype, titled “Game Game”. I’ve finally reached the point in development where I can make this level, which is incredibly exciting. I still need to develop a system to create the “game” part of it, but my current progress let’s me create the map and move between rooms.

Adding all of the objects to the game was time consuming, but I already had the system in place to make this happen. Getting the game to work across multiple rooms, and adding functionality to move between them, was a lot trickier.

I came up with a system that would let the player place an “Enter Warp” and an “Exit Warp”. With this, the player can move between rooms during the play mode of the game. Here’s the system:

First you create a path to room you want to go to:

Then you create a path going back to the previous room:

The system is a bit more complex then I had hoped. Having to place four tiles just to move back and forth between two rooms is a bit much. Ideally the player would only have to place two tiles, but a system like that would require a system to rotate objects. It’s possible that I will add a system like that in the future, but for now the warp system I’ve set up is perfectly fine.

Here is the final result in moving between rooms during play mode:

Right now the transition between rooms is a bit jarring since it happens instantly. I’ll be adding in a fade in / fade out system in the near future to fix this.


Revising The Creation System (DevLog 5)

This week I spent a significant amount of time developing a more efficient creation system. Below you can see the old creation system:

giphy (1)
Old System

With this method I was “creating” the objects by having them all off screen. Then when the player clicks in the play area, the object appears on the mouse cursor as if it was being created instantaneously.

I’m not able to just create duplicates of one object because each object has to be able to hold different properties. For instance, each bed needs to be able to hold a different message variable. If I were making duplicates of one object, then each bed would always display the same message.

This method of having every bed off screen was incredibly inefficient. If I wanted to have the ability to create 10 of each object per room, then I would have to place 10 objects in each room. If I wanted to have the ability to create 99 rooms in the game, then I would need 990 different bed objects in the game. This is not only a poor use of memory, but also a waste of time in creating 990 of each object.

I needed to come up with a better way of only creating an object off screen when I needed it. I developed the system that you see below:

New System

This new method creates new objects off screen when necessary. If I place bed 0 in the level, then bed 1 is immediately created off screen to be placed next. This method is scalable across rooms, so if I’ve used bed 0 and bed 1 in the first room, then bed 2 will be created off screen in the second room when I begin editing there. Additionally, instead of having to create 990 of each object in the game, I can simple create 99 of each object and limit the amount of objects the player can place per game to 99; (99 beds, 99 nightstands, etc.).

This week I hope to develop a system to create multiple rooms within the game. I’ll start with a basic prototype to get it working and then implement the final system later on.

Overhauling the Design (DevLog 4)

A few weeks ago I wrote about a blog post from Soren Johnson, a member of the team that developed Spore, and it’s really stuck with me ever since. He describes how Spore had two big ideas: one about powers of 10, the other about procedural generation. Johnson argues that only one of these ideas was ever any good (procedural generation) and that this idea should have been re-evaluated compared to the initial idea (powers of 10). He gives the following advice: “Don’t be afraid to challenge the initial vision”.

I hit a point last week where it was finally time to challenge the initial vision of the game. My thesis is a game about making a game. Originally my game was going to consist of two separate parts: one where you “make” the game; the other where you play the game. The part where you make the game was going to be very limited, with only the ability to place objects wherever you want them. After you complete this,  you would then play the game as it was intended to be played: a linear, scripted story experience. The ability to place objects wherever you want was meant to serve as a way to give the player feel a sense of ownership over what they were playing.

However, the idea of a level editor within the game was a great idea that I was treating as a throwaway one. I began re-evaluating the first idea of a linear, story experience, against the second idea, of a RPG level editor. I realized that the second idea was the more promising of the two, and immediately started thinking of ways to develop a comprehensive RPG game creator.

Super Mario Maker Inspiration


Super Mario Maker is currently my main inspiration for the design of my game. It features one of the most brilliant level editor creation tools to ever exist in a video game. The simple layout and interface allows players to begin creating something immediately without any knowledge of how the engine works. It’s simple and intuitive, which is what a level editor should be. And since Super Mario Maker was designed to work on the Wii U’s touch pad, it’s perfect inspiration for my own game which is being designed for mobile.

I began the design process by starting simple: a menu on the top of the screen that let’s you place objects in the level. I created a system that let’s you select an item and then allows you to place the item by tapping on the screen. From here, I also added the ability to drag an item from the menu to be placed on the screen. So now there are two methods of placing objects in the level: selecting from the menu and tapping on the screen, or dragging from the menu to the screen. Finally, I added an erase button that removes placed objects from the screen.

My next step was creating two separate modes: an “editing” mode and “playing” mode. In the editing mode, you can build your level and place objects, and in playing mode, you can move the player around and test out your level.

As for my dilemma last week, I decided that I’ll be upscaling the game rather than downscaling the game. With downscaling, I can achieve 60 fps, which has a much better feel for dragging items around the screen. Otherwise the game feels too laggy at 30 fps. It’s possible that I’ll attempt to port the game from GameMaker to Unity in the future, or make a potential sequel inside of Unity instead of GameMaker, so that I can have non-pixel art visuals in the game.

Customizing Placed Objects

I’m currently working on a system that let’s you customize each object that you place. The player can choose what type of action happens when they interact with a certain object. These are the interactions I’m planning on implementing over the next few weeks:

  • Message Appears; with ability to customize each message
  • Initiate RPG Battle
  • Teleport to Another Room
  • Increase Health
  • Decrease Health
  • Death Screen

So far I’ve implemented a system that allows the player to input a unique message for each object, and when the player interacts with the object it shows the message. I want to allow for up to 5 unique interactions for each object depending on the player’s current health, or what items they have in their inventory.

Updated Progress (3.9.16)

While I’m in the process of writing an in depth dev blog for this coming week, here are the things that I’ve accomplished:

  • Revamped the level editor design
  • Created a system that lets you select items from a menu to place into the level
  • Added an erase button to remove objects from the level
  • Added in player movement to the new system
  • Created an object collision system
  • Cleaned up all the previous code

Form or Function? (DevLog 3)

dev log4

Drawing Text

A few days ago when I was trying to figure the best way to draw text. The problem was this: the resolution of the game was very low, and in order to accommodate different screen sizes I was scaling the game up. For example, the game’s view for a 16:9 device was 568×320, and say the device had a resolution of 1920×1080, it would have to scale the game up 3.3X in size to fit the display.

This is a big problem for drawing text. If you’re drawing text relative to a small view (568×320), scaling the game up is going to stretch out the pixels, making the text have jagged edges. This isn’t a problem if you’re dealing entirely with pixel art or drawing a blocky font. Pixel art can scale up and still look the same as it does on the smaller view; same with a blocky font, such as those found in 8-bit games. However, I did not want to be limited to only using an 8-bit font, so I needed to change the way my game handled scaling.

The only solution for this is to scale down instead of scaling up. When you scale the game down it allows all of the images in your game to remain looking crisp, including any text. For GameMaker, drawing text requires an additional step which is to turn on “texture_set_interpolation”. Then it’s necessary to turn it off again after you’ve finished drawing the text. This essentially smooths out any remaining jagged edges due to the scaling of the game.

Now that I’m scaling down, I’ll have to create all of my artwork at a higher resolution. The target resolution that I’m going for is 1920×1080, the standard for HD, and depending on the device being used, the game will either scale up or down to fit the resolution. If scaling up from 1920×1080, the text that is using “texture_set_interpolation” will likely appear blurry, which is something I don’t have a solution for.

The only downside to scaling down is that it takes up more memory and is more taxing on the system. My target frames per second for my game was originally 60 fps, but now that I’m scaling down it will likely be 30 instead. This is an issue with GameMaker, but may not be a problem with more powerful platforms such as Unity.

Disabling Surfaces for Android

In the previous week’s dev blog, I posted a video of a quick prototype for the level editor. The game was running slowly and was very laggy on Android, but I had assumed this was because I was testing with a USB cable from my computer. The game was running perfectly on Windows, so I didn’t see any reason why it would be running slower on Android. I figured the game would run faster once it was exported as an Android App.

However, I read this post from someone on the GameMaker forums claiming that disabling the application surface would improve the frames per second. I started debugging my game to see how many frames I was achieving on Android, (I had the application_surface enabled and I was using other surfaces for scaling on top of that), and I was getting around 17 fps. Once I deactivated the application surface and figured out a method to scale without using surfaces, I was able to achieve 60 frames per second. This of course was when I was still scaling up, so now I’m achieving 30-40 frames per second on Android.

A New Dilemma

I’m faced with a tough choice going forward, but one that won’t really affect anything until I start the final artwork for the game. Do I scale the game down? Or do I scale the game up? If I scale down, I’m going to be able to have “HD” visuals within the game, but I’m sacrificing frame rate if the game can only run at 30 fps. If I scale up, I will be limited to having only pixel graphics and block fonts, but I will be able to run the game at 60 fps.

After some testing on Android, moving objects around at 30 fps doesn’t seem fast enough. With the level editor, it definitely has a better feel when moving objects around at 60 fps. So the question is: Do I sacrifice visuals in favor of functionality? Or vice versa?

In a few days I will post another dev blog to shed some light on recent design changes I’ve made to the game, as well as any updates on whether I’ll be scaling up or down going forward.

Testing on Android (DevLog 2)

This week I was finally able to test on android. I set everything up following this guide on GameMaker’s site and successfully got things running on my Samsung tablet. You can check out the video above to see the game running and my progress so far.
I had some difficulties at first getting it to display correctly on my device, but then I realized I had forgotten to change the Android settings in GameMaker to match the Windows settings I was testing on before. After that, everything worked perfectly.
With the code that I finished last week for scaling, the screen scaled to my device automatically. My tablet’s screen is 1280×800 pixels, so 1280/800 is 1.6, meaning it has a 16:10 ratio. Based on that, the game changes the view to fill up any extra screen space and eliminate any black bars on the sides.
I’m in the process of creating a simple level editor for my game. This is what Ive created so far:
  • Able to move objects around
  • Objects snap to a 32×32 grid
  • Can’t place objects on top of one another
  • Can’t place objects outside of the level
  • Able to tap to move with a character
  • Buttons for “debug mode” and “level editor mode”
Eventually once the player moves all the objects where they want in the level, they’ll “debug” the game and walk around with the character to make sure they can interact with each object. They’ll also be able to turn collisions on and off for each object if they wish.
Here are some of the things I want to get done for next week:
  • Test on iOS
  • Create a virtual d-pad (I may not end up using this or I may just have it act as a secondary control scheme)
  • Create a button that takes you to the home screen of the game, where you can access your email, Kickstarter page, and other applications
  • Incorporate the device’s system clock into the game to display the current date and time

The Witness and Undertale (blog)


There are only two games that I’ve really played in recent weeks, and they are The Witness and Undertale. The Witness is a 3D, first-person puzzle game set on an abandoned island. It is the second game from Jonathan Blow, and his follow up to Braid, which I’m realizing more and more that I need to go back and play. Undertale is a 2D, RPG game made by Toby Fox, and was released to critical acclaim last year. So how do these two games relate to what I’m trying to accomplish with my own game?

Communicating To The Player

The Witness is brilliant; it manages to communicate every aspect of the game without using language. In a way, the game creates its own language, one that you can decipher on your own accord. Instead of informing the player of the mechanics behind a type of puzzle, it lets the player discover them on their own. Too many games today inform the player exactly what they are supposed to do, and assume that the player won’t be able to figure it out on their own.

Screen Shot 2016-02-17 at 3.29.06 AM.png

This is an element that I’ve been thinking about a lot with my own game. My first prototype of the game featured too many “You should do this, then you should do this” moments, where I told the player exactly what they needed to do at every part. This helped me get an idea of the events that I wanted to take place in the level, but it didn’t make for a very fun game. This is a problem that I’m still working out with the design. How do I have all the scripted events happen within the level, but still allow the player to feel as if they’re doing everything on their own accord? This is something that I can definitely learn from The Witness, and while I’m not going to eliminate all of the language and instruction from my game, I think that only utilizing it when absolutely necessary will make for a better experience.

Then there’s Undertale… a game with a lot of text, but one that utilizes the RPG genre style of writing to its advantage. It’s a game that’s been universally praised for its great writing and its diverse set of characters. At the moment, my own game doesn’t feature any other characters besides the player; the player only interacts with emails and online crowdfunding backers in the desktop game, and in the RPG game, the player only interacts with objects. However, it is worth noting how Undertale handles the player interacting with objects:

In Undertale, the text never refers to the player in the first person, only in the third person. So for my own game, do I have the perspective be from the 3rd person, as in “you found x object”, or from the first person, as in “I found x object”? That’s something that I still haven’t settled on, but I think Undertale’s method of referring to everything in the 3rd person works well for its own style of gameplay.

Also, another consideration, do I explain every object within the game when you click on it? Undertale has a text box pop up, giving some insight on whatever you just interacted with. It’s a simple feature that adds a lot to the game, but I’m not sure if it will work as well with my own game. However, it’ll be worth experimenting with both, text and no text.

Game Audio and Music

The Witness features no music within the game, something that very few games can pull off to their advantage. I just finished reading this blog from Jonathan Blow posted in November of last year, detailing his reasoning for not including music within The Witness. He notes that since the game is about being perceptive and noticing the subtleties in the environment, adding music on top of that would work against the game. Instead, they put more attention into creating the sounds of the world around the player, to maximize the immersion within the world, instead of detracting from it with music.

Undertale on the other hand, has a fantastic original soundtrack composed entirely by Toby Fox. Nearly every section of the game features an original composition, and as he explains in this interview, he would write the songs of the game before he started programming a specific section. This helped him to decide how the scene should go. On top of that, since Undertale‘s soundtrack was so well-received by fans, he’s been selling it on his Bandcamp for $9.99, making additionally money on top of the [already strong] sales for the game.

While the music choices of The Witness and Undertale fall on two opposite ends, the music for my game will most likely  fall somewhere in between. Audio is still an aspect of my game that I haven’t decided on, but I already have a melody in mind for the theme of the game. Beyond that, it will take some experimentation with what works / doesn’t work for my own game.