8-Bit Warrior Games + Design + Tutorials + Random


Insane Number Run (Made with GameMaker)

Insane Number Run

Available on iOS, Android, and Kongregate.

I recently finished up work on a new game, Insane Number Run, for Happy Bacon Studios.  It is a relatively simple game where you must, counting up, reveal all hidden numbers in order.  Its development started with the intent to make a small game with a quick production cycle but, like many projects, it took longer than expected to polish things and have it feel "just right". For those curious, it was created using GameMaker: Studio, which generally makes development an enjoyable experience.

Feel free to check it out. Reviews are appreciated! :)



[PersistGMS v0.2.0] – Custom Room Persistence for GameMaker: Studio (EXPERIMENTAL)


Currently, it should only be used for smaller projects or learning purposes.
Documentation can be found in the 'Create Event' of obj_PersistentManager.



.gmz Example Project (outdated)



PersistGMS provides a foundation for custom room persistence in GameMaker. It is designed to be easy to use. Simply add the objects you want to remain persistent for each room to a list contained in obj_PersistentManager. For now, only the x/y values of persistent objects are recorded, but this can easily be extended to suit specific needs.

Feel free to check out the example project, or download and directly import obj_PersistentManager.object.gmx into your own project. There is no need to download additional scripts or .dll files.

Designed to work across all target platforms (Windows, Mac, Linux, iOS, Android, HTML5).
Feel free to report any bugs or design issues you face.

Persistent Action!


Tagged as: , , , No Comments

TweenGMS – GameMaker: Studio Tweening Engine

TweenGMS is a feature-rich tweening engine for GameMaker: Studio which is both easy-to-use and flexible. With nearly 3 years of development, it offers many essential and advanced features powered by an optimised codebase.

Quickly improve the look of your games by tweening movements, fades, rotations, animations, paths, stats, and much more!

Available on GameMaker Marketplace:

TweenGMS Pro / TweenGMS Lite

HTML5 Demo

[ Features ]

  • Fire-and-forget tweening
  • Step and seconds(delta) timing
  • Time scale contol (global and per-tween)
  • Play modes (once,bounce,patrol,loop,repeat)
  • State control (pause,resume,stop,finish,reverse)
  • View, tile, path, background, and data structure support
  • Automatic memory and persistence handling
  • Advanced callback system
  • Custom variable easing
  • Delayed tweens
  • Control groups
  • Heavily optimised
  • Clean and organised
  • Supports all platforms
  • Examples and game project included
  • And more...


Original Free Version  (Unsupported)

Twitter Dev Log


If building HTML5 games with GameMaker: Studio, be sure to check out JCHTML5, which includes TweenGMS, to help make things even easier when developing for the web.


Candy Crash – A Halloween Game

I recently had a sudden urge to make a Halloween game. As a result, I quickly whipped something together in about three days. Enjoy all its super amazingness+1!

It is Halloween night!
Well past your bedtime, you have landed the biggest score of candy ever. However, on your way back home, you have tripped and spilled your candy all over. Already high on too much sugar, your imagination goes wild as you find yourself caught in a monster mash.

You must recover as much candy as you can before you are overcome by your wild fears of ghosts, ghouls, vampire bats and spooky graveyards.

Local Scoreboard
Solid Touch Controls
Fun Challenging Atmosphere
A Kid in a Ninja Costume!
Pumpkins and Jack-o'-lanterns!

HTML5 Version
Play Now

Available for Android devices via
Google Play
Direct APK download

Available for iOS devices via

Available for Windows via
Direct Download

Available for Mac via
Direct Download


[Game Maker] Bettering 4-Direction Player Movement

If you find this tutorial helpful, please consider showing support by trying my latest game
Insane Number Run
Insane Number Run***

This tutorial assumes you have some experience with Game Maker's scripting language, GML.
However, even if you are unfamiliar with it, you should still be able to follow along and find this useful if you take the time to understand it.

Controlling a character in any game should be as intuitive as possible for the player.
Thus, control should function in a predictable manner and avoid any little quirks that could arise and leave your player falling down an endless pit.

One small quirk I'd like to address here revolves around 4 direction character control, and the issue of key direction input/release dominance.
To help illustrate this issue, play around with the character in this example:

Take note of what happens when you have one direction held and then press down another while holding on to the first direction. Then, try holding down the second direction first and press down the original direction afterwards. Do you notice anything odd?

If you play around with the rest of the directions, trying the different combinations of starting with one direction and then pressing and holding another, you will find there are keys with dominance over other keys. It doesn't care which key was pressed last, but only which key returns true. But if more than one key direction returns true, it simply takes the first key returning true and uses it.

We will now look at one solution for this issue.

Note: This solution includes both ARROW/WASD key movement.

1) Start a game maker project and create an object called obj_input and set it as persistent

2) Inside obj_input, add Event -> Create create

3) Inside the Create event, add -> Code code for initializing a few global variables

g_keyDirection,             // holds value for active direction key pressed
g_keyDirectionIsPressed,    // is true when direction key first pressed down
g_keyDirectionIsReleased;   // is true when direction key is released

g_keyDirection = -1; // initialize as -1 to ensure no initial false input
g_keyDirectionIsPressed = false;
g_keyDirectionIsReleased = false;

4) Inside obj_input, add Event -> Begin Step step

5) In this event, add -> Code code to check for the last direction pressed and set g_keyDirection/g_keyDirectionPressed accordingly:

    // First, clear global Pressed/Released states
g_keyDirectionIsPressed = false;
g_keyDirectionIsReleased = false;

    // Second, Check for ARROW or WASD presses
if (keyboard_check_pressed(vk_right) 
or  keyboard_check_pressed(ord('D')))
    g_keyDirection = 0;
    g_keyDirectionIsPressed = true;
if (keyboard_check_pressed(vk_up)
or  keyboard_check_pressed(ord('W')))
    g_keyDirection = 90;
    g_keyDirectionIsPressed = true;
if (keyboard_check_pressed(vk_left)
or  keyboard_check_pressed(ord('A')))
    g_keyDirection = 180;
    g_keyDirectionIsPressed = true;
if (keyboard_check_pressed(vk_down)
or  keyboard_check_pressed(ord('S')))
    g_keyDirection = 270;
    g_keyDirectionIsPressed = true;

Okay, this is great, but what about key release variances? If a player has two keys pressed and releases one of them, it should always return the direction to the remaining key held.

6) Add the following code below the code we just wrote in the Begin Step event

   // Third, Check for ARROW or WASD releases
if (keyboard_check_released(vk_right) // Arrow keys
or  keyboard_check_released(vk_up)
or  keyboard_check_released(vk_left)
or  keyboard_check_released(vk_down)
or  keyboard_check_released(ord('D')) // WASD keys
or  keyboard_check_released(ord('W'))
or  keyboard_check_released(ord('A'))
or  keyboard_check_released(ord('S')))
    g_keyDirectionIsReleased = true;
    g_keyDirection = -1; // Make sure to clear this first
    if (keyboard_check(vk_right)) g_keyDirection = 0;   else
    if (keyboard_check(vk_up))    g_keyDirection = 90;  else
    if (keyboard_check(vk_left))  g_keyDirection = 180; else
    if (keyboard_check(vk_down))  g_keyDirection = 270; else
    if (keyboard_check(ord('D'))) g_keyDirection = 0;   else
    if (keyboard_check(ord('W'))) g_keyDirection = 90;  else
    if (keyboard_check(ord('A'))) g_keyDirection = 180; else
    if (keyboard_check(ord('S'))) g_keyDirection = 270;

There, once you have added obj_input to your game's starting room (remember to make it persistent!), you should now be able to have any object in your game access the g_keyDirection variable and set its movement accordingly. You also have access to g_keyDirectionIsPressed and g_keyDirectionIsReleased for when you need to use those states.
For example,

7) Create an object called obj_player

8) Inside obj_player, add Event-> Step step containing -> Code code for moving the player accordingly

    // Set speed and direction when key pressed
if (g_keyDirectionIsPressed)
    speed = 4;
    if (g_keyDirection == 0)   direction = 0;
    if (g_keyDirection == 90)  direction = 90;
    if (g_keyDirection == 180) direction = 180;
    if (g_keyDirection == 270) direction = 270;

    // Or simply... 
    // direction = g_keyDirection;

    // Set speed and direction when key released
if (g_keyDirectionIsReleased)
    if (g_keyDirection == -1)  speed = 0; // Stop if no direction pressed
    else if (g_keyDirection == 0)   direction = 0;
    else if (g_keyDirection == 90)  direction = 90;
    else if (g_keyDirection == 180) direction = 180;
    else if (g_keyDirection == 270) direction = 270;


Now, the second direction key pressed will always be dominate when two keys are pressed down, and when a direction key is released, the remaining key pressed will take over as one would hope.
The character movement should now be like this:

Again, notice the difference when compared with the BAD CONTROL EXAMPLE

You can download the completed example gmk for Game Maker here:

[Windows Version]


[Mac Version]


If you have any questions or comments, feel free to contact me!