In my [last post](/machine-learning/a-game-developer-learns-machine-learning-a-little-deeper/) we dug a little deeper into machine learning by starting from scratch and training an agent on a vastly simplified version of mr nibbles. In this post we will explore what happens when we step it up a notch and attempt to train on a significantly more complex version of the game.



# The Series

If you are new to the series I recommend you checkout the previous posts first, here's the whole series:

0. [A Game Developer Learns Machine Learning - Intent](/machine-learning/a-game-developer-learns-machine-learning-intent/)
1. [A Game Developer Learns Machine Learning - Getting Started](/machine-learning/a-game-developer-learns-machine-learning-getting-started/)
1. [A Game Developer Learns Machine Learning - A Little Deeper](/machine-learning/a-game-developer-learns-machine-learning-a-little-deeper/)
1. A Game Developer Learns Machine Learning - Mr Nibbles Basics

# Code

If you want to see the code for this post then checkout this tag: https://github.com/mikecann/MrNibblesML/tree/MrNibblesBasicsBlogPost

# Mr Nibbles Forever vs Mr Nibbles

My original [Intent](/machine-learning/a-game-developer-learns-machine-learning-intent/) was to teach an ML agent to learn my game [Mr Nibbles Forever](http://epicshrimp.com/app/mrnibblesforever/). Based on my experience up to this point I think what might be easier is to begin with trying to train an agent to learn a game similar to "[Mr Nibbles](http://mr-nibbles.com/)" instead of "[Mr Nibbles Forever](http://epicshrimp.com/app/mrnibblesforever/)".

<iframe width="853" height="480" src="https://www.youtube.com/embed/lyAf7VVLdKg" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

Rather than an endless procedurally generated game like Mr Nibbles Forever, Mr Nibbles is a level-based platform-puzzler.

I suspect that Mr Nibbles will be easyier to learn as it's significantly less complex than its later variant, Mr Nibbles Forever.

# The Environment

Before I can even think about training my agent, I need an environment. Mr Nibbles was originally made many years ago in HaXe and thus I will need a way to build levels in Unity.

Unity recently launched a [set of tools](https://docs.unity3d.com/Manual/Tilemap-Painting.html) for generating tile-based games.

So I set to work using those tools to construct some levels:

<iframe width="853" height="480" src="https://www.youtube.com/embed/99TRpAmZFYM" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

I borrowed some code from Unity's [tutorial on platform games](https://unity3d.com/learn/tutorials/topics/2d-game-creation/creating-basic-platformer-game) to build a "Platform Controller" for Mr Nibbles. This is the thing that actually controls the how mr nibbles moves given an input.

I added a little of flourish in the way of big tubes to represent the entrance and exit points for the level. I even wrote some code that animated Mr Nibbles through the tubes but I found that it caused issues in the training so I decided to drop that aspect for now, perhaps ill add it again later.

The end result is that you are able to play a number of levels as mr nibbles. When you reach the exit another level is randomly selected and Mr Nibbles is spawned into that.

<iframe width="853" height="480" src="https://www.youtube.com/embed/IHdPzaLRY98" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

# The Agent

With the levels built its time to code up the agent.

## State

What information do we need to tell the network about the state of the world that will allow it to successfully learn how to navigate it?

Well we obviously need to supply the position of Mr Nibbles and the position of the exit point.

```csharp
public override List<float> CollectState()
{
    var state = new List<float>();

    state.Add(_exitPoint.transform.position.x);
    state.Add(_exitPoint.transform.position.y);

    state.Add(_platformController.transform.position.x);
    state.Add(_platformController.transform.position.y);

    return state;
}
```

We should probably also supply a variable to help with learning the potential set of actions depending if the player is in the air or not.

```csharp
public override List<float> CollectState()
{
    var state = new List<float>();

    ...

    state.Add(_player.IsGrounded ? 1 : 0);

    return state;
}
```

Im not sure if this is really needed but I thought it cant hurt.

Now for the hard part. How do I represent the level? I cant really pass in the collision bounds for each tile as that would be too complicated to represent as floats.

Each level is constructed as tiles, so everything sits on a uniform grid. So I should only need to pass in the centre point of each tile in the level along with its type and hopefully that should be enough for the agent from.

![](./tile-xy-pos.jpg)

The next issue is; how do I deal with different level sizes? [This GitHub issue](https://github.com/Unity-Technologies/ml-agents/issues/139) mentions that the state size needs to be fixed (I believe this is to do with the way TensorFlow works under the hood).

This restriction is going to make things a little tricky because our levels are different sizes with a different number of tiles, so keeping the state size the same for each level may be a problem (more on potential solutions to that later).

For now my "just get it working" solution is just to make sure the levels are quite small then grab all the tiles in a certain bounds. If the tile is empty I set its type to "0" if its a solid tile its "1" and if its a spider its "2".

![](./tile-types-rendered.jpg)

When the level changes I grab the tiles from the tilemaps:

```csharp
public BoundsInt tileBoundsToIncludeInState = new BoundsInt(-25, -1, 0, 40, 1, 1);

public override void AgentReset()
{
    ...
    _tiles = _game.CurrentLevel.GetComponentInChildren<TilesController>().GetTiles(tileBoundsToIncludeInState);
    ...
}
```

Then feed them into the state list:

```csharp
public override List<float> CollectState()
{
    ...

    foreach (var tile in _tiles)
    {
        state.Add(tile.position.x);
        state.Add(tile.position.y);
        state.Add(tile.type);
    }

    ...
}
```

## Actions

Now we have our state, we need to allow the agent to take and action and receive a reward or punishment for that action.

```csharp
public override void AgentStep(float[] actions)
{
    PerformActions(actions);
    UpdateRewards();
}
```

Digging into `PerformActions` first:

```csharp
public const int None = 0;
public const int MoveLeft = 1;
public const int MoveRight = 2;
public const int Jump = 3;

...

private void PerformActions(float[] actions)
{
    var nothing = (int) actions[None] == 1;
    var moveLeft = (int) actions[MoveLeft] == 1;
    var moveRight = (int) actions[MoveRight] == 1;
    var jump = (int) actions[Jump] == 1;

    var isJumping = false;
    var hozMove = 0f;

    if (moveLeft)
        hozMove = -1f;
    if (moveRight)
        hozMove = 1f;
    if (jump)
        isJumping = true;

    _platformController.Tick(hozMove, isJumping);
}
```

I handle the condition where the player can perform none, one or all of the actions simultaneously. I then pass those actions to the platform controller component which updates the physics of mr nibbles.

Now we need to handle how to reward the agent for its actions:

```csharp
private void UpdateRewards()
{
    if (_exitPoint.IsTriggered)
    {
        Wins++;
        reward = 10;
        done = true;
    }
    else if (_spiders.IsTriggered)
    {
        Deaths++;
        reward = -10;
        done = true;
    }
    else
    {
        reward = -0.01f;
    }
}
```

The agent is rewarded for reaching the exit, punished for touching the spiders and given a small punishment for each moment that goes by that it doesnt reach the exit.

Im not sure if these are the correct values, I played around with a few different values but im not sure if these are correct or not.

# Defining Brain and Academy

[As with my last post](/machine-learning/a-game-developer-learns-machine-learning-a-little-deeper/) I am going to leave the academy empty for now, I dont need its features as I dont have multiple agents in my scene.

The brain is setup like so:

![](./brain-setup.png)

We have defined the number of states: tiles (x,y,type) + agent state (x,y,isOnGround) + exit point (x,y) = 1505

The number of actions: jump, left, right, nothing (stand still).

The action space is set to continuous because we want to allow the agent to perform multiple actions at once, jump and move right for example.

The state space is continuous because we arent dealing with integer positions for things in the level rather we are using floats.

# Training

With the environment constructed lets move onto training. First I need to get the hyperparameters right for the PPO algorithm. I re-read [the unity best practices doc](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/best-practices-ppo.md) and took a guess at the following hyperparams:

```python
### General parameters
max_steps = 5e5 # Set maximum number of steps to run environment.
run_path = "mrnibbles/run14-differentrewards" # The sub-directory name for model and summary statistics
load_model = False # Whether to load a saved model.
train_model = True # Whether to train the model.
summary_freq = 10000 # Frequency at which to save training statistics.
save_freq = 50000 # Frequency at which to save model.
env_name = "mrnibbles" # Name of the training environment file.
curriculum_file = None

### Algorithm-specific parameters for tuning
gamma = 0.99 # Reward discount rate.
lambd = 0.95 # Lambda parameter for GAE.
time_horizon = 1500 # How many steps to collect per agent before adding to buffer.
beta = 1e-3 # Strength of entropy regularization
num_epoch = 6 # Number of gradient descent steps per batch of experiences.
num_layers = 2 # Number of hidden layers between state/observation encoding and value/policy layers.
epsilon = 0.2 # Acceptable threshold around ratio of old and new policy probabilities.
buffer_size = 10000 # How large the experience buffer should be before gradient descent.
learning_rate = 3e-4 # Model learning rate.
hidden_units = 64 # Number of units in hidden layer.
batch_size = 2500 # How many experiences per gradient descent update step.
normalize = False
```

I kicked off training and fired up TensorBoard. After a few different attempts I felt like I had something that was training so I let it run for an hour or so:

![](./tensorboard.png)

It looks okay, we can see that the cumulative reward increases sharply and levels off and the episode length decreases as the agent learns to play the level.

When we try our model out in the game however we see this:

<iframe width="853" height="480" src="https://www.youtube.com/embed/S21Rkob0XfM" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

On the positive side, it looks like he is attempting to move towards the exit point when the exit is to the right of the spawn point. On the negative side he doesnt ever seem to want to try going left and also seems to get stuck for a long time at a small hurdle.

I think whats going on is the levels where the exit point is to the left of the spawn point have spiders, thus they are significantly more difficult for the agent to solve than the levels where the exit point is to the right of the spawn point. As a result the agent has learnt that probably it should always just go right and is unable to learn that it can jump over the spiders.

It looks like the agent is having trouble with jumping in general..

# Future Work

I tried a few smaller tweaks but none seemed to have a significant effect. I think what I need to to change my training strategy.

## Curriculum Training

While browsing through the Unity docs I came across the concept of [curriculum training](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/curriculum.md). As I understand it; you incrementally train your agent with progressively more difficult scenarios thus accelerating the learning by focusing the agent on learning just one aspect of your game at a time. This reminds me of how humans learn in school, we aren't immediately thrown into quantum mechanics, instead we start with basic mathematics and work our way up from there.

I think my next set of experiments will have to take advantage of curriculum learning by slowly introducing level elements until the agent is able to successfully proceed.

## Tile Radius State

One current limitation of my current setup is that I encode the state of the entire level. This means I am currently limited to small levels of fixed size.

A solution (suggested by a member of [my local Machine Learning meetup group](https://perthmlgroup.wordpress.com/)) is to only provide the state of tiles that lie in a radius around Mr Nibbles. As Mr Nibbles moves so to does the nearest surrounding tiles. This is analogous to using a camera as my input state but unlike camera state the agent should be able to learn [temporal information](https://github.com/Unity-Technologies/ml-agents/issues/183).

## Reward Tweaking

I think I may need to work on how I reward and punish a little bit more. Perhaps I should have a timeout if it takes the agent too long to solve a level, maybe that would prevent it from learning that on certain levels its best just to suicide rather than try to solve the level.

## Velocity

Another potential issue is was unable to learn to jump correctly was because it was missing information about its velocity. I was hoping it could infer the velocity based on the previous positional state of mr nibbles but perhaps it would help if I manually supplied that information as two more state parameters.

# Conclusion

Well I cant really call this post a success, but I certainty learnt a lot and that's the ultimate goal. I have lots of ideas for how to proceed from here so subscribe to stay tuned.

Until next time!

P.S. If you want to see the code for this post then checkout this tag: https://github.com/mikecann/MrNibblesML/tree/MrNibblesBasicsBlogPost

Well its been almost two weeks since [I declared the (tough) scheduled plan](https://www.mikecann.blog/myprojects/mr-nibbles-forever-getting-it-done/) for the release of Mr Nibbles Forever. In it I planned that last week was to be:



> 22nd-28th June
>
> 1. Design landing page for the game. This is important as I will need a place to put the trailer and to send people who are interested in the game. I have read several good resources on how this page should look. Some examples of other landing pages are: https://www.pixelprospector.com/list-of-websites-and-blogs-from-game-developers/. Once landing page is designed, run it pass some designer friends for help improving it.
>
> 2. Pester people for feedback on Alpha 8\. I need to get some real-world feedback for the game so I can fix bugs and improve the polish for release 9.
>
> 3. Contact some marketing people for help and advice.

Well I managed to do 1) and 2) but I decided that I didnt need to do 3) just yet, instead I made do with the excellent advice on these two pages:

https://vgamemarketing.com/
https://www.pixelprospector.com/

I may go back to 3) in a week or two if I need to.

As for 1) well I decided after an hour or two of messing around in Photoshop that it would be easier and faster to just buy an off-the-shelf WordPress theme and adjust that to my needs as I was intimately familiar with WordPress. The theme I chose was [Grizzly from Wegrass](https://themeforest.net/item/grizzly-responsive-app-showcase-corporate/1546240):

[![2015-07-03_07-33-47](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-33-47-300x231.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-33-47.png)

It seemed to have all the features I needed for now and was responsive which is super important these days.

The next issue was what name should I call the "company". Up until now I had been going with the name "Nibblers" as that was the name that "Mr Nibbles" was published under too. "Nibblers" however is very specific to Mr Nibbles games and if I wanted to do non-nibbles games in the future it would sound a little odd so I needed a new name.

After much head scratching I decided I wanted to base the name around my favorite animal the Mantis Shrimp. If you dont know what it is, then checkout [the oatmeal's excellent bit on it](https://theoatmeal.com/comics/mantis_shrimp). The problem was that mantisshrimp.com is taken, also its difficult to tell someone the domain, as they either dont know how to spell it or are confused as to how many S'es there are in the middle.

So in the end I decided to go with something that was related and instead use the Mantis Shrimp in the logo. So I went with.... Epic Shrimp:

[![2015-07-03_07-41-32](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-41-32-1024x728.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-41-32.png)

The site is still very much under development but at least I now have a good landing page for Mr Nibbles, Ectoplasm and Mr Nibbles Forever:

![2015-07-03_07-43-27](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-43-27.png)

So although last week was supposed to just be design, I decided to go the full-hog and implement too, which means that I have one more week free for development.

Speaking of development, this week we [supposed to be a bug-fixing and polish pass](https://www.mikecann.blog/myprojects/mr-nibbles-forever-getting-it-done/):

> 29th June – 5th July
>
> 1. Do bug-fixing and polish pass of the game. Push release 9 of the game to people for testing and feedback.

Its true that I did indeed fix some minor bugs...

![2015-07-03_07-46-39](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-46-39.png)

... this week was mostly dedicated to improving the high scores system in the game.

As a result of some feedback from people I decided that the game needs to be more in-your-face about the competitive aspect. Hopefully this will encourage people to return more often so that they can try to get higher up the leader boards.

I was unsatisfied with my current GameCentre and GoolgePlayServices implementation of the highscores so I decided to roll my own using my Parse.com experience. So now you will notice that next to the high-scores button that every each play you are given your daily rank:

[![2015-07-03_07-49-39](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-49-39-1024x772.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-49-39.png)

Clicking the button will show you the top ranked players in each category:

[![2015-07-03_07-51-51](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-51-51-1024x768.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-51-51.png)

You will notice that your name is "???" until you set your name:

[![2015-07-03_07-54-31](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-54-31-1024x763.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-54-31.png)

Once done, all your old and new scores will now be saved under that name, this works across devices too.

[![2015-07-03_07-55-33](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-55-33-1024x773.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-55-33.png)

I am also experimenting around with having a button next to any high score which also has a saved replay.

[![2015-07-03_07-57-26](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-57-26-1024x763.png)](https://www.mikecann.blog/wp-content/uploads/2015/07/2015-07-03_07-57-26.png)

Clicking the button will open Everyplay and show the recorded run for that highscore, which I think is pretty cool!

Well that's it for now, this weekend I am going to be extremely busy on something else (more in another blog post soon) so I wont have any more time, but hopefully next week will either be more bug fixing and polish and getting more feedback on the game.

As usual if you would like to try the game and are on iOS then just email me: mike.cann@gmail.com, or if you are Android then join this page: [https://plus.google.com/u/0/communities/100690884724496136044](https://plus.google.com/u/0/communities/100690884724496136044)

Until next week!

Well i'm now 8 weeks into development of Mr Nibbles Forever and I can safely say that the game is now feature complete (this probably should be Beta 1 release then not Apha 7 but oh well :P). I didn't do a release last week as I had quite a bit of other work on and so there wasn't all that much progress so I thought I would skip a week.



In this release:

![this-week](https://www.mikecann.blog/wp-content/uploads/2015/03/this-week.png)

Thats all from my [Trello board](https://trello.com/b/Ic11WQzF/mr-nibbles-forever) for the project, the numbers are the amount of time I spent on each one (red is time taken, blue is estimate)

Before I get into some of the details you can see some of the new stuff in this video:

<iframe width="1280" height="750" src="https://www.youtube.com/embed/0NR5bTPx15k" frameborder="0" allowfullscreen></iframe>

As you can see I have added a couple more particle effects and a new power up, the double jump. This meant changing some of the chunks so the player could not jump out of the world. I also added some "secret" areas that the player cant get to unless they have the double jump.

I have also added fruit to the game and "fruit collection" challenges. I have placed fruit in strategic locations in some of the chunks. These locations are often alternate routes to the normal one and are harder to get to, so you take a risk getting to them. I haven't decided what to do with the fruit when a challenge isn't currently active, for now I have just made it so that a fruit is worth 5 nibbles, let me know what you think!

In this release I have also added the Everyplay game recording service. I use this service to record every run in the game, then give the player the option to watch and share it. Hopefully this will encourage social engagement and drive new players to the game and encourage existing players to play more. I introduce this to the player when you complete the first challenge:

[![IMG_0163[1]](https://www.mikecann.blog/wp-content/uploads/2015/03/IMG_01631-1024x768.png)](https://www.mikecann.blog/wp-content/uploads/2015/03/IMG_01631.png)

If you click watch replay then the Everyplay service starts up:

[![IMG_0164[1]](https://www.mikecann.blog/wp-content/uploads/2015/03/IMG_01641-1024x768.png)](https://www.mikecann.blog/wp-content/uploads/2015/03/IMG_01641.png)

You can even provide a narration to your video using the front facing camera (click to watch)!

[![2015-03-14_11-32-10](https://www.mikecann.blog/wp-content/uploads/2015/03/2015-03-14_11-32-10.png)](https://everyplay.com/videos/14904453)

I also added IAP so you can purchase outfits if you don't have the patience to collect the nibbles and spin the week. There is also high scores in there now for iOS that uses Game Center.

So the game is pretty much done now apart from the missing artwork and audio. I have been speaking to various Artists and audio people for a few weeks now so hopefully things should start to come together by next week.

As usual if you would like to test out the iOS version just shoot me an email: mike.cann@gmail.com or if you are on Android then join [this community](https://plus.google.com/communities/100690884724496136044).

The 4th week of development is over and although I haven't had as much time as I would have liked this week (reinstalled windows AGAIN, prepared for my open-water swim) I still managed to make some significant progress, checkout the video below:


<iframe width="1280" height="750" src="https://www.youtube.com/embed/CK_iMVFTiu0" frameborder="0" allowfullscreen></iframe>

I have managed to the "Wheel of Fortune" in and the "Dressing Room". They aren't quite complete yet but you can see where i'm going with it. You can spend your collected nibbles on the wheel:

[![2015-02-09_09-43-42](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-09_09-43-42-1024x664.png)](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-09_09-43-42.png)

You can win a variety of prizes:

![2015-02-09_09-44-45](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-09_09-44-45.png)

At the moment there are two types of prizes "Powerups" and "Outfits". Powerups may be things like an extra life or a free respin of the wheel or slow-mo. Outfits will change the appearance of Mr Nibbles as you play the game. I intend for there to be quite a few to choose from:

[![2015-02-09_09-47-11](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-09_09-47-11-1024x576.png)](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-09_09-47-11.png)

The outfits wont just change the way Mr Nibbles looks they may do extra things such add particle effects, trails or different sounds. Im hoping this will provide the extra variance to the game that will keep the player playing, striving to get more nibbles and a better score.

I am planning on using the "Crossy Road / Bitcoin Billionaire" monetisation strategy, incentivized ads with a sprinkling of IAP. Incentivised ads on FB was not allowed but it seems like its okay to do this ([and do it to make some serious money](https://www.google.com.au/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0CB0QFjAA&url=http%3A%2F%2Fwww.businessinsider.com%2Fcross-road-made-over-a-million-dollars-from-video-ads-2015-1&ei=XhLYVO28E5HN8gW9nIGoBQ&usg=AFQjCNGggJtWNB4jFUygOTqfE9UCsAAnBg&sig2=HMjCzS9FEPRMboL1rEfqcw&bvm=bv.85464276,d.dGc)) on mobile.

I have had far less time than I would have liked to work on the game this week mainly because it was my birthday over the weekend and quite a bit of time was spent preparing for that.



The little time I did have however was spent on two main things. Firstly the video:

<iframe width="854" height="510" src="https://www.youtube.com/embed/q-mv6LWmtBQ" frameborder="0" allowfullscreen></iframe>

The first thing I worked on was adding a new type of chunk that serves as a sort of tutorial to teach the player to tilt the device to slow Mr Nibbles down or speed him up as this seems to be the biggest sticking point with people regarding the controls.

The hanging spiders force the player to slow down and the sign hopefully shows them they do that by tilting the screen:

[![2015-02-02_10-03-16](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-02_10-03-16-1024x617.png)](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-02_10-03-16.png)

I have a bit more work do do on this before its done but I hope it will help teach people the controls, let me know if it works!

Because this chunk acts as a tutorial it needs to go near the start of the level so the second major bit of work this week was to create a "scriptable sequence" that lets me dictate the type of chunk that needs to spawn:

![2015-02-02_10-12-39](https://www.mikecann.blog/wp-content/uploads/2015/02/2015-02-02_10-12-39.png)

Previously the chunks were randomly selected based on the difficulty which was based on the distance the player had travelled through the game. Now that its scripted its much more controllable but hopefully still leaves a lot of room for the randomness that makes the game replayable.

Other than that there was a host of other small changes in this release:

- Added menus music
- Added options for enabling and disabling sounds and music to the main menu
- Chunks now correctly join together seamlessly
- Added an in game pause button and pause menu
- Added a loading progress bar
- The backyard theme collapsible floor now looks like dirt rather than cage.
- Added unity analytics
- Fixed the chunk testing tool
- Fixed the squeaky sound effects issue

As usual if you would like to play the iOS version email me: mike.cann@gmail.com, the android version can be played if you join this group: [https://plus.google.com/communities/100690884724496136044](https://plus.google.com/communities/100690884724496136044) or just join the facebook page to stay up to date with updates: [https://www.facebook.com/mrnibblesforever](https://www.facebook.com/mrnibblesforever)

[![](/wp-content/uploads/2012/09/header.jpg "header")](/wp-content/uploads/2012/09/header.jpg)

Well its been a couple of weeks since we launched on iOS and a few weeks since Android, so I have decided to write one more post on the Mr Nibbles project. A post mortem into what went right, what went not so right which should hopefully serve to solidify my learning from the process and perhaps help others who should embark on something similar.



Before I dive into that, first some statistics thus far..

## Statistics

**Android**

[![](/wp-content/uploads/2012/09/2012-09-02_1250.png "2012-09-02_1250")](/wp-content/uploads/2012/09/2012-09-02_1250.png)

We have had 2,867 User installs and 1,623 active device installs. Not bad :)

**iOS**

[![](/wp-content/uploads/2012/09/2012-09-02_1252.png "2012-09-02_1252")](/wp-content/uploads/2012/09/2012-09-02_1252.png)

3,789 iOS installs, making a grand total of 6,656 mobile installs, not bad :)

## The Process

So from [the beginning](/posts/lets-make-a-mobile-game-in-3-weeks-with-haxe-nme/) the this project was to be a quick turn around project. The idea was to try and complete the whole thing in three weeks. It actually ended up being more like 5 weeks for me and 4 weeks for Moh the artist (he was on holiday for one of those) but still not months of development which I wanted to stay clear of.

For me, short time-scale games are so much more fun to make than long games. In a short time you can iterate quickly over the core idea then get it out there quickly and see what people think. When time constrained you are are forced to only implement the core functionality and discard the rest. In all likelihood the other stuff is probably just fluff anyways and not really necessary to the game.

As for the time-overrun, there is no one main reason for it. Lots of small things such as; unfamiliarity with NME / iOS / Android development, windows / osx development workflow and testing taking longer than expected. Making and testing each of the 30 levels took alot more time that I had anticipated. Working around some small NME issues (more on that below) took some time. Writing these blog posts every week (sometimes more) took some time out of what could have been development time too (more on blogging below).

The hours we worked on the project were actually okay. Because this was a personal project and both of us have full time jobs at [Playdemic](https://www.playdemic.com/) we could only work on the game during our evenings and weekends. During week days we tended to start about 6-6:30pm then work until we were kicked out of the office by the security guard. 8:30-ish usually. Occasionally (mostly towards the end of the project) we stayed a little later to get stuff done before release.

![](/wp-content/uploads/2012/09/testing.jpg "testing")

This sort of schedule and working pattern suited us both. Being able to see who you are working with and talking face to face I think really adds to the experience and fun of making an indie game. Its definitely more exiting to run over and show the other person some cool new level on your iPad rather than try to describe it over MSN from your bedroom. Working like this obviously wouldn't have been possible if the management at Playdemic weren't so awesome by allowing us to use the office after normal office hours so definitely a massive thanks there.

## Blogging

I strongly feel that blogging everything is one part of the process I definitely wouldn't change. Sometimes I choose to work in private on some projects however  this one I decided to be very public, announcing upfront the intent and regularly updating on progress. Blogging regularly and getting feedback on progress really encouraged me to stick with it every singe evening. It also served as a way to keep the project fun (absolutely critical for me) as the immediate feedback from people would serve as a basis for ideas and improvements.

Also writing things down has been proven to encourage stronger learning and memory retention, so hopefully in the future I wont make the same mistakes ;)

## Haxe + NME

I have been using [Haxe](https://haxe.org) for over a year now for various personal and professional projects so I was fairly familiar with the language going into this project. Haxe is a good language, similar to AS3 / ECMA based langues and so it shouldn't feel too alien to a seasoned flash developer. It does however come loaded with many improvements over AS3 such as proper generics, type inference, macros and many more awesome features.

[NME](https://haxenme.org) is a library built ontop of Haxe. It provides a familiar flash api but is able to many platforms natively. Using exactly the same Haxe code base I was able to compile Mr Nibbles to Flash, iOS, Android, Blackberry, Windows and OSX thanks to NME. The library really is great for this sort of fast-turn-around game. Mr Nibbles certainty wouldn't have been possible without it (not in 5-weeks anyways).

![](/wp-content/uploads/2012/09/testing2.jpg "testing2")The NME developers have put a lot of time into making the build and certification process as easy as possible for the various platforms. So with "nme setup android" from the command line for example you are able to download and setup the android SDKs and get your certs setup in the correct place for building. Its really great to see that sort of dedication to making the cross platform compilation process as smooth as possible.

The performance of NME is truly great. Thanks to its batched sprite rendering there are very few draw calls and expensive texture-switching. Mr Nibbles runs at solid frame rates on pretty much every smartphone you can think of from the Android G1to the Galaxy S III to the iPhone 3G to the iPad3\. After having worked with the[ nightmare that is J2ME mobile games](/posts/worms-2/) in the past, being able to run your game on so many devices without any code changes really is a pleasure.

NME isn't perfect however and does have a few issues such as slow and imperfect vector rendering from SWF files. It is however constantly constantly being worked on and im sure it wont be long before the issues are ironed out.

Because both NME, Haxe and most of the third-party libraries are open source you are always free to dive in and fix any issues yourself. For Mr Nibbles, the SWF rendering was "good enough", such that we were able to make nice looking menu screens that dynamically scaled to any device resolution and pixel density (a real time saver!). Most of the time when I ran into the issue I would post it on the NME mailing list. More often than not it would be answered (often by the NME-super-hero [Joshua Granick](https://www.joshuagranick.com)) within an hour or less!

## iOS

iOS was definitely the primary platform we were developing Mr Nibbles for. Mostly because it was the platform I owned a mobile and tablet device for ;) To develop for iOS you need to use osx and xcode, so I took my MBP into the office and hooked it up via Ethernet to the network. I setup a shared folder on my desktop machine and the pointed xcode on my MBP to that shared folder. That way whenever I made a change on my windows computer I would only have to hit one button in OSX to rebuild and test on my iOS device. It was a real time saver over the other approach I was previously using, syncing over Dropbox.

There were are few frustrating moments towards the end of the project when I was running into issues regarding ArmV6 and ArmV7 when NME was compiling. Fortunately I noticed in the [nmml spec](https://www.google.co.uk/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCMQFjAA&url=http%3A%2F%2Fcode.google.com%2Fp%2Fnekonme%2Fsource%2Fbrowse%2Ftrunk%2Ftools%2Fcommand-line%2Fspec.nmml&ei=If9EUI7UN4ez0QWYkYHQCw&usg=AFQjCNEl3n-oz1tHz4ZPceTNYidpyTxolA) for NME there was an option to compile to "FAT" which seemed to make the issue to away ;)

## Android

Android was a lot easier to iterate and test because it could all be done from my desktop machine. In hindsight, and with the devices that only became available towards the end of the project, it would have been better if we had concentrated on the Android build first then ported to iOS later. Once we had some devices to test on however I was incredibly impressed with how easy it was to build and launch the game onto an Android device with NME. Literally just "nme test android" from the command line and it would compile and launch directly to the[![](/wp-content/uploads/2012/09/522085_10151008075505740_663326715_n-300x224.jpeg "522085_10151008075505740_663326715_n")](/wp-content/uploads/2012/09/522085_10151008075505740_663326715_n.jpeg) device, no faffing about.

Since launch there have been a few issues with audio crashing on Android. However I believe some people have been working on this so I may do a new build of Android in the near future and push an update of the game to the Google Play store.

## Blackberry

The blackberry build has only been finished very recently, hence the lack of stats thus far. It was actually really easy to build for Blackberry, again just a matter of changing a single word on the command line "nme rebuild blackberry" and that was it.

The hardest part was testing it as I had no Blackberry device to test on. Joshua Granick was extremely kind and offered to test the game out on his device. Not only that, he put in a kind word and managed to get a Playbook shipped out to me so I could test too, thanks Joshua :)

## Conclusion

Overall I had an absolute blast working on this game. Sure it was hard work, alot of evenings and weekend spent in the office till 9pm and sure it went over budget by two week but it doesnt matter because I was having fun the entire time.

This is what making games is all about for me, if you want to have fun programming I cant think of a better way than to make than to develop short-project games. Haxe with NME were instrumental in making the process as fun as possible by taking out much of the bull sh\*t with cross-platform development, letting you get down to business of turning your ideas into reality. So massive thanks to everyone that has worked on developing Haxe and NME.

Finally I want to say a massive thanks to my colleague and artist partner on this project Moh who's time and hard work made Mr Nibbles come alive, nice one Moh!