Projection in snowball fixed.

Pretty happy with this progress. I fixed the numnbers and managed to get the projection working correctly. Though a major problem i had was the original code I referred to for this style assumed an anchor point of being smack in the middle of the sprite. MelonJS like a lot of 2d game engines defaults to top left for the anchor point.

In MelonJS 3, a lot of work was done to fix the anchor point and improve it's capabilities. So once I updated from 2.1.3 to 3.0, and fixed my code to follow the changes, the projection essentially fixed itself. So now, it looks like this:

The updated game is playable here:

Snowball v2

A little bit ago I decided to take a break from the stealth prototype, and revisit my snowball game to make it good.

I have a game out on ios already, and you can play it on in your browser here: I decided to re-visit it as I feel like I can make it a much better game. What i've done so far is got rid of the level system, and I'm going towards an infinite runner. Where instead of having a max length of a slope, you just keep going. Slowly getting bigger. As you collide into things, you fill up a skill bar. You can use this resource to have snowmen launch themselves at fire pits. I have other ideas as well for things like jumping, putting an ice shield on you, etc. The dev version is available here:

If you hit too many fire pits, or other traps and get to small, game over. The idea is to keep growing and stay alive as long as possible.

Another major flaw with the game is the fact the backdrop is not all that interesting. So something I am working on now is making it more dynamic. Instead of a static image, im going about implementing a 3d feel similar to retro car/racing games. What i have so far:

The trees still need to be redone. But i have the collidable objects rendering on the slope. The calculations still need some adjustment. Once I have that right, I can update the trees to render along side the slope properly, and add terrain to the side as well.

From there add things like curves, and and down hill, etc.

Stealth Prototype - The first hack, one of many i hope

As I mentioned in the last post the focus of this prototype is going to be sneaking, and hacking to avoid enemies as supposed to killing. So I wanted to add a hackable wall that allows you to circumvent the enemies. It's a vent duct of sorts that you can sneak into. The hacking for it is super simple, just a press button with a timer.

Note that nothing visually differs the wall to show it's an area. This is something i plan to change, but I still want to keep it a bit secret. You need to brush up against a small section, roughly two tiles high, and then you can press E like the UI says. Once you do, a bar starts filling up:

Due to the fact it takes time, you're at risk while standing there. As displayed before, an enemy will either chase you, or shoot you straight away. So you need to make sure to time it properly. This is one of the things I really enjoy about game development: tweaking and cleaning up the gameplay. Making it so it's challenging, but fair. It's hard to pull off in some cases, but feels great when it works. Planning is very important. I sketch out level ideas and type out design concepts, but you won't know what works out until you try.

Once the hack finishes, you can go through the wall:

As you can probably tell, the walls on each end still look like walls. Their needs to be a way to identify the wall tiles on both sides of the vent are now passable. Something along the lines of hide or change their image when the wall is hacked. Without that, it's hard to know what the hack actually did. For all the player knows, maybe the hack disabled a turret further down the path. That's the next thing I plan to work on.

Hacking needs to be more interesting than this. Nothing coded yet, but did a sketch on the UI I'm thinking of:

The first sketch is a bit messy due to edits. But the left section is meant to be a metallic keypad of values 1 through 9. The second device attached by a cable scans the code over time. Filling the numbers, similar to the green numbers filling in at the start of The Matrix. Type in the number wrong and click the confirm button, the alarm goes and guards will come to your position.

The second sketch involves a metal plate that has a screen on it. The attachment takes a few seconds, and scans the unlock pattern. A similar unlock mechanism to that of android phones. You join the dots together to unlock it. 2-3 failed attempts will cause it to fail, and guards will come after you.

The Start of a Stealth Prototype

For the past month I've been working on a top down 2D stealth prototype. The game itself will evolve into much more than a stealth game I hope. I have bigger ideas for it, but for now I want to explore some of the concepts and ensure they will work.

So like most prototypes you start off drawing simple shapes, or using very little art, much like below:

As you can see the walls have boxes around them which are collidable bodies. The first level here is static. It's broken up into individual parts, and placed relative to each level. Using libgdx this process was actually fairly straight forward. What took some more doing was getting the camera to clamp to the edges of the level, while still following the player.

Movement with box2d, even arcade movement is pretty straight forward. Just have to set linear velocity accordingly. I've read from others in the past "don't use a physics engine for a platformer!". Honestly, I disagree. While you can point to funny examples like Box2D tetris, using it correctly can yield a lot of benefits. AABB collision & correction can be simple, but once you want to use polygon shapes, or triangles. I have 45 degree angle walls for example. It gets much harder on the math. I'm not very good at physics stuff, so I leverage Box2D.

Once the level got layed out, it needed some guards:

The guards have a cone vision, very similar to that of metal gear solid. The AI is super simple right now. There's two modes: chase or shoot. Both types start off patrolling from one point to another. If they catch you in their cone, they switch to their designated mode. The Chase one is pretty straight forward:

The red signifies you've been spotted, and the npc will chase you. If the npc catches you, you're done. If you get away, the NPC goes to your last position and looks around for a second:

It's pretty neat, but I have to say i'm not finding it compelling enough. I'm going to explore more group mentality with the NPCs in the near future. The AI in a stealth game needs to be perfect. For the shoot npc, if you get caught you die. They are very unforgiving, and will shoot you quickly and deadly.

The general view for the character at this time is completely non violent. They will use cunning and technical skills to hack around their enemies. Once I get the AI the way I want it, hacking puzzles and work arounds in the level is what I will explore next.

Thoughts on multi platform solutions

A couple days ago, I was at a JavaScript hacknight here in Toronto. I know the organizer (Dann) reasonably well, as i've been going to these events and other ones like it for a few years now.

I myself have been diving into cross platform solutions for a while, typically involving the JavaScript stack. I've messed around with nwjs a bit for desktop html5 games. I've used cordova for a couple projects at work to create android & iOS apps. I've written HTML5 games with various web libraries that are bundled in cocoonJS for the mobile app stores.

More recently for web content, I've been learning ReactJS. I have also watched the recent talks on React Native. All of these tools I find tend to serve two main purposes that the native frameworks do not:

  1. You can write the applications in a language you're familiar with
  2. Have more transferable code.

Obviously these vary from framework to framework. I'm sure we'll be using different components in iOS vs android environments with React Native.

I started talking with Dann about building native mac & windows apps with html+css+js and using NWJS, and how it almost feels wrong. Like we are clinging to the stack almost too much. No doubt it can be done, and can be done well. Atom is a good example of this. But I think there are limits.

Now let's say I wanted to build a markdown editor, as I'm picky and don't care much for the ones that exist already. The abstraction to native APIs that I would need would be writing to the file system. NodeJS makes this pretty simple, so an application like this is quite practical to build using a JavaScript stack.

What if I wanted to do something more complicated than that? What if I wanted to do a garage band type application? Where I'm able to record from an audio input device, split up a track, adjust volume levels, and export an mp3. This really steps up the difficulty. I'm sure it's doable with our beloved JS stack, but it's going to be much more practical using Cocoa APIs, and likewise the newer APIs in windows 8. Obviously that kind of application is much larger and vastly more complicated than the markdown editor. However, as I've worked on Cordova apps at work, it's easy to run into little problems here and there that an existing plugin doesn't solve. So you either end up writing your own plugin, or doing a bunch of hacky solutions JavaScript side, or you just leave it as a bad experience.

Over the last couple days, I have been doing some eesearch at work. The goal is to take 4 photos with an iOS app, and turn them into an animated gif. This gif would also require a client logo watermark on top, and it to be grayscaled. My tech lead found a pretty decent JavaScript plugin for putting images or video together to make a gif. However, the only way I could make it work with pure Javascript code, was to take 4 photos individually. Four calls to the camera plugin: ->
  launch camera plugin ->
    take photo ->
      confirm/retake ->

That was for each of the four pictures, so around 12 button presses. That's no good. My tech lead managed to find a tutorial on doing a custom camera plugin. We figured might as well try it for a couple hours, and see if it's practical. So I got started on it from the tutorial. I added some minor changes to it, as it had a couple bugs. Once I could take a single photo, I modified the Objective-C code a little bit to add an array of photo urls. Applied the resize & grayscale, then passed the array to the webview. This only took a few hours of work total. If I were to just pass the raw images to the web view, I'd have to then using multiple async calls to the file system. Resizing them with the canvas and grayscaling them would be so much more work, especially due to memory limitations of the webview. The simple & synchronous code on the iOS side made it this process much easier.

Now granted, if this project was going on android, windows phone and other devices, it becomes a bigger task to maintain the code base. But I felt quite pleased on the results when building a feature in the native side. At least this way, we can still leverage our design team on HTML & CSS. I know from now on that with Cordova, if we need more than the plugins provide us, there is a way.

I brought these kind of examples to Dann's attention. He responded, which I'm paraphrasing "It is quite silly that we have to use different languages for these platforms. Android runs Java, and iOS runs Objective C/Swift, this just adds friction for developers that want to build applications. It's these greivances that causes us to explore solutions that can work for each device. We create a common API that invokes the proper specific calls based on the platform."

He's absolute right about that. Frameworks like Titanium and Cordova do go for the write once, run everywher approach. However, with the speed that android & iOS move at, it's hard to keep up with all the native APIs. With Titanium, you can't write native components, you're stuffed if their API doesn't do something you need it to. This could very well apply to React Native.

That said, I do think it's worth it. I think with enough brains behind it all, and push for good practices, we can make these cross platform solutions work. Looking back in our history of hardware and cross platform support, very smart people worked on compilers that could work with various CPU architectures, so we could write things like C code on various computers. The web browser gives us a JavaScript run time that works fairly reliably across platforms. In the gaming world we have transpilers of HLSL to GLSL. Blizzard Entertainment has supported Mac & Windows games for years, signifying they must have tools for writing D3D code and OpenGL code with a native API.

But of course, we still have platform detection code. In game code I sometimes see #if windows, #if osx type calls. We will write different versions of shaders depending on the OpenGL version supported. Older code we wrote platform specific stuff, with the cordova app I wrote platform specific stuff. We all need to be smart on when we use certain tools. At the end of the day, use the right tools to deliver the experience you want to deliver.

Working on art, level design, it's tricky stuff

Kudos to all you artists and designers out there. I know it's a tricky skill and takes years to develop, but I have even more respect for you after trying to make my own assets for Search For Hope. A short, 2D platformer that I am working on.

I haven't published my latest changes to my site because I like my deploys of games to be somewhat stable. But here are some visual updates that I've done.

The background for the intro now has some smoke/dark clouds above to hopefully give a more eerie atmosphere. I also added the cracks to the buildings/windows to show more destruction. I find this kind of challenging, as one really needs solid imagery to go with when they don't have the practice.

I updated some of the existing tiles, and added a few new ones. Mainly the dark gray rock tiles to have different shapes & edges to give it that more organic look for the underground. Again pretty simple art here, just trying to get by until I really get the game fledget out.

You'll notice a few lighter pieces in the middle. Those haven't been updated yet, but the theme of them is still accurate. The overall idea is that the further down you go, the better and more positive the scenery gets. And it keeps improving that way until you find the character a new home.

WebGL - Partial textures

This was something that took me a bit to understand when working with WebGL. When you draw a texture, you're going to be mapping coordinates of the texture to the coordinates you specify in your vertices array.


var x1 = object.pos.x;
var y1 = object.pos.y;
var x2 = object.pos.x + object.width;
var y2 = object.pos.y + object.height;

We have 4 variables, each for the different coordinates of a game object.

var vertices = [
  x1, y1,
  x2, y1,
  x1, y2,
  x1, y2,
  x2, y1,
  x2, y2

So we setup the two triangles to draw the square.

Top Left -> Top Right -> Bottom Left

Bottom Left -> Top Right -> Bottom Right

In 2d games, I typically prefer to have the Y value go up as you go down the screen, as supposed to the default. So I flip the coordinate in with a uniform matrix in a shader. This sit here shows how to set this up: Because of this, the texture coordinates get a little weird.

The texture i have below is 128x128. Be sure to always have them power of 2 and square.

What i want to draw is the 0, 0 32x32 of the image. My object that I showed earlier has the proper width & height values. So we just need to tell webgl where to start with the texture, and use those width & height properties.

WebGL texture coordinates and OpenGL for that matter always specify between 0 and 1. For x, 0 is the furthest left coordinate, 1 is the furthest right. 0.5 is in the middle. So we basically work this as a percentage:

var dw = (object.width / object.texture.image.width);
var dh = 1.0 - (object.height / object.texture.image.height);

The texture property is the created texture for actual drawing. The image property on that is the raw image data. I use that to get the true size of the image.

Though why am I taking a 1.0 value and subtracting the height? It's because of the Y flip. This is what got me for a bit when trying to get this to work. Because we have the Y flip in the uniform matrix, and not before the texture coords are all said & done, we need to use opposite Y values. So from there, I simply draw out what I need:

var textureCoords = [
  0.0, 1.0,
  dw, 1.0,
  0.0, dh,
  0.0, dh,
  dw, 1.0,
  dw, dh

As I said, each coordinate there is in order and maps to the coordinates in the vertices.

[0.0, 1.0] => [x1, y1]
[dw, 1.0] => [x2, y1]
[0.0, dh] => [x1, y2]
[0.0, dh] => [x1, y2]
[dw, 1.0] => [x2, y1]
[dw, dh] => [x2, y2]

We map the bottom left corner to the top left corner, the bottom corner, 32 pixels in to the top right corner, and so forth. The x position always stays the same, but I flipped the Y.

I hope this post helps.

Submitting your CocoonJS xcode project

As per my twitter, I ran into some issues with trying to validate my CocoonJS game. I'm sure there are some better ways to do it from what Ludei gives you, but I eventually managed to solve it by doing the following:

While I had uploaded an icon to Ludei's dev portal, I had the necessary files on my local machine as well. If you have them, be sure they follow the naming convention here: If you don't have them, simply:

  1. right-click on the xcodeproject file that you downloaded from ludei.
  2. Click Show File Contents
  3. Browse into appData
  4. Copy the Icon* image files into a local directory

Now that you have your icons named properly, copy them to the same folder as your xcode project file. You can have them in antoher folder here, but keep them in the project folder.

In xcode, you need to add the files to your project & build process:

  1. Click File
  2. Click Add Files to "Project Name"
  3. Select the image files.
  4. Click on your project target on the left side.
  5. Under general, App Icons, you should see the icons unfullfilled with a caution sign. Depending on your deployment targets, you'll need to provide an image for the various sizes. Refer to the above link for the necessary sizes. Add the images from the project.
  6. Click Build Phases
  7. Click the + at the top (above target dependencies for me)
  8. Click New Copy Files Build Phase
  9. Leave the options as they are, and press the plus button.
  10. Select the image files/folder.

Now you're ready. Be sure to test the application by deploying it your device. Ludei gives a pretty good guide on setting up your provisioning profile and deploying to your device here:

Once you're ready, go to the product menu, and click "Archive". This creates the .ipa file, and makes it all set to go for uploading.

The organizer will open (Press CMD+Shift+2) if it doesn't. And be sure you see your icon besize the project name. Then press validate, and follow the wizard.

You want to make sure the validator gives you zero warnings & zero errors before you Distribute it to the app store.

Hope this helps, as this was a pretty big pain point for me,

Snowball Effect - dev updates

I really need to update more often on this project. I've done some experimenting with the game on making it infinite. I found that had little merit, so ditched the idea and decided to stick with levels.

I am aiming to have 3-4 levels in it before I launch it on both the iOS App store, and Google Play.

Feature updates

  • Fixed a bug on iOS mobile safari where the snowball would disappear
  • Made minor speed changes to level one. It now progresses a bit slower on difficulty.
  • Level two has been added. It spawns two fire traps, leading to more rapidly occuring hazards.
  • Skiers added as a target in level two.
  • Level selection menu after pressing start:
 Level selection menu

Level selection menu

You can play the current development version with a modern browser here.

Still to come, is setting up level three. I have a few things I hope to add to level three:

  • Slower speed, but more hazards
  • Add a second hazard type that is a bit larger, with higher damage, but spawns rarely.
  • Terrain/button press jumps. The ability to jump over smaller hazards is something I'd like to put in.

Thanks for reading!