I have generally steered away from building open-source libraries mainly for selfish reasons (I didn't want to spend the time maintaining them) but I decided that the current work I was doing would benefit from input and improvement from others and so I decided to release two things as libraries and im really happy with how things went.



Both libraries are for MobX State Tree (MST) [which I have been using for quite some time](/posts/markd-2-total-re-write-using-react-mobx-state-tree-and-parse-server/) now. Its a fantastic library for managing your state in a clear and concise way tho there are some gotchas with parts of it. These libraries try to help with some of those gotchas and thus increase reliability when using MST.

# MST Flow Pipe

https://github.com/mikecann/mst-flow-pipe

This is a helper library for writing type-safe async code in MobX State Tree.

I wont go into all the details of how this one works, you can click the link above to read the readme. Briefly tho I felt that MST's async story was a little lacking when combined with Typescript so set out to improve it with this library.

I first talked about it on [this issue](https://github.com/mobxjs/mobx-state-tree/issues/1516) which prompted me to release the lib.

My first version had some corner cases that didn't work quite right but thankfully [@lorefnon](https://github.com/lorefnon) picked up from where I left off and submitted [a PR](https://github.com/mikecann/mst-flow-pipe/pull/1) which greatly improved the library. Now it works fantastically, is infinitely expandable and handles errors in an elegant way.

Im really happy with the state of the library and I think the concepts could be borrowed and used in other libraries that use JS-generators instead of JS-promises such as [redux-saga](https://redux-saga.js.org/).

# MST Log

[![](./mst-log-screenshot01.png)](./mst-log-screenshot01.png)

A console logging middleware for MobX State Tree

This one came about after some work with Redux and [redux-logger](https://github.com/LogRocket/redux-logger) which beautifully shows actions and state changes as groups in the console window. I thought this was really cool and couldn't find anything comparable in the MobX State Tree world so [I posted on the Spectrum group](https://spectrum.chat/mobx-state-tree/general/a-good-logger~206ccd36-527b-4f09-b7f0-fcbef90b407d) about it to see if anyone else was interested in it.

MST has some conceptual differences from Redux so some of the choices I made around nesting and grouping async calls may not be 100% correct. Im hoping that others will point out issues and help contribute to make it better. So far tho I am using it on our [BattleTabs](http://battletabs.com/) project to great effect.

> This is part of a three-post series on working with Parse.com in Unity. For more info please see the other posts in the series:
>
> [Part 1 - Intro and App Structure](https://www.mikecann.blog/programming/working-with-parse-com-in-unity-3d-part-1-intro-and-app-structure/)
>
> Part 2 - Services, Helpers and Looming
>
> [Part 3 - Tests, Typescript and Common Code](https://www.mikecann.blog/programming/working-with-parse-com-in-unity-part-3-tests-typescript-and-common-code/)



In the last post I covered the basic app structure, in this post I want to cover some of the specifics of the front end, the Unity part.

**Note all the code talked about can be found in the [Parse Unity Sample Project on Github.](https://github.com/mikecann/ParseUnitySampleProject)**

## Services

I like to split my code up so that all the work that involves dealing with remote services are contained within "Service" classes. The service classes are responsible for taking game data and turning it into a form that the remote service can deal with, then translating the result and passing it back to the game.

In the sample project I have just one service, the UserService, which is responsible for logging a user in or signing them up or logging them out, basically all functionality that that concerns the "GameUser" class.

### Tasks

Lets take a look at the Login method in the UserService class:

[code lang="csharp"]
public Task<GameUser> Login(string email, string password)
{
Debug.Log("Logging in..");

    return ParseUser.LogInAsync(email, password)
    	.OnMainThread()
    	.Then(t => Task.FromResult((GameUser)t.Result));

}
[/code]

We can see that it takes in an email and password then logs in for us and returns a Task<GameUser>.

Parse uses Tasks throughout its Unity SDK as a way of handling asynchronicity. You will probably familiar with Tasks if you have done any work with aync / await in C# 5 or greater.

Unity runs on an old version of C# it doesn't have any concept of Tasks baked in so Parse includes the System.Threading.Tasks namespace. Although Unity does not have any support for async / await you can still use the Tasks API in a [Javascript-like Promise way](https://www.html5rocks.com/en/tutorials/es6/promises/).

Tasks allow us to provide a callback method that will be called when the Task returns, which allows the game to continue on running while we wait for the server to respond. For example, this is how we call Login:

[code lang="csharp"]
private void Login()
{
isLoading = true;
userService.Login(usernameInp.text, passwordInp.text)
.Then(OnLoggedIn, OnLoginError);  
}

private void OnLoginError(Exception e)
{
isLoading = false;
menus.ErrorPopup.Open("Error logging in!");
}

private void OnLoggedIn(GameUser user)
{
isLoading = false;  
 menus.States.SetState("Logged In State");
}
[/code]

The Then function after login is being called on the Task<GameUser> and is the first of my helper libraries that I have included in the sample project which imports my [Unity Parse Helpers](https://github.com/mikecann/Unity-Parse-Helpers) library.

In that library I have included a number of extension methods for Task that allow you to chain functions together for example from the SignupState:

[code lang="csharp"]
private void Signup()
{
isLoading = true;

    // Signup
    userService.Signup(usernameInp.text, passwordInp.text, playernameInp.text)

    	// Then Login
    	.Then(t => userService.Login(usernameInp.text, passwordInp.text))

    	// Then we are done
    	.Then(OnLoggedIn, OnError);

}
[/code]

This makes chaining asynchronous logic together in Unity a breeze and you don't ever have to deal with the headache of using yeild!

## Threading

The first major headache I came across when using Parse in Unity is to do with threading. Note from my earlier example of Login in UserService:

[code lang="csharp"]
public Task<GameUser> Login(string email, string password)
{
Debug.Log("Logging in..");

    return ParseUser.LogInAsync(email, password)
    	.OnMainThread()
    	.Then(t => Task.FromResult((GameUser)t.Result));

}
[/code]

The function "OnMainThread" is a helper extension I wrote to deal with the threading issue. If we were to remove that function then when we try to login Unity would throw an error something like:

[![2014-11-11_08-07-43](https://www.mikecann.blog/wp-content/uploads/2014/11/2014-11-11_08-07-43.png)](https://www.mikecann.blog/wp-content/uploads/2014/11/2014-11-11_08-07-43.png)

This is because below the covers Parse is making web calls on a separate thread and when it returns the result is passed back to us without returning to be main thread and pretty much everything in Unity needs to happen on the main thread so when we try to access a variable that lives on the main thread Unity crashes.

There are a few ways around this issue, Parse documents that you can [use coroutines](https://www.parse.com/docs/unity_guide#tasks-coroutines) to deal with this, but I would really rather not have to use coroutines so instead I used another common solution, a "Loomer".

A Loomer basically just takes a function and waits until the game is running on the main thread before executing the function. So behind the scenes my "OnMainThread" extension function is calling the loomer which ensures that any Tasks that follow it will execute on the main thread:

[code lang="csharp"]
public static Task<T> OnMainThread<T>(this Task<T> task)
{
var tcs = new TaskCompletionSource<T>();
var loom = Loom.Instance;

    Action<Task<T>> a = t =>
    {
    	loom.QueueOnMainThread(() =>
    	{
    		if (t.IsFaulted) tcs.SetException(t.Exception);
    		else if (t.IsCanceled) tcs.SetCanceled();
    		else { tcs.SetResult(t.Result); }
    	});
    };

    task.ContinueWith(a);
    return tcs.Task;

}
[/code]

So whenever you call Parse functions in your services just make sure you call "OnMainThread()" and you should be good to go!

On a separate note, I have already [previously mentioned](https://www.mikecann.blog/programming/fixing-unitys-internal-compiler-error/) that if you are going to write extension methods for Tasks you must make sure that you sepparate your action from the ContinueWith() else you will get an internal compiler error in Unity!

## Errors

Unfortunately there is an issue in Unity with Parse that means that we cannot get proper error messages back from the server. For example if a user mistypes their email address when logging in all we get is a HTTP error code like "404 - Not found", this is obviously not particularly helpful. Parse does actually return a better error than which can be seen if you use the Rest or .Net API but whatever reason in Unity that error message gets lost.

This is probably the single biggest drawback with using Parse.com with Unity but it is apparently a [fundemental issue with Unity](https://www.parse.com/questions/unity-sdk-handling-errors). I have [started a thread on the Parse Google Group](https://groups.google.com/forum/#!topic/parse-developers/s4tw8iiSpAA) to see if we can get an update on this but im not holding any hope. I did hear a rumor that the new version of the Unity compiler (shipping in Unity 5+) will finally include improvements to network stack.

Generally you can work around it as you can guess what the issue is if an error occurs and handle it in your business logic. Its still really annoying however particularly when it comes to debugging and testing, hence why I have devoted another post to that very subject..

## To Be Continued...

And thats basically it for dealing with Parse.com in Unity, I strongly reccomend [checking out the source](https://github.com/mikecann/ParseUnitySampleProject) if you need more information on anything I have covered, hopefully it makes more sense.

In the [next part](https://www.mikecann.blog/programming/working-with-parse-com-in-unity-part-3-tests-typescript-and-common-code/) ill talk about how to structure your backend so that you can easily test your cloud code.

During the development of my up and coming game I have encountered some snags when developing in Unity so I wrote a number of utilities and extension methods to help out.



One such annoyance is the inability to use interfaces in GetComponent() and GetComponents(), so I wrote some extension methods to help with that:

[code lang="csharp"]
using UnityHelpers;

var obj = new GameObject();
obj.AddComponent<MyComponent>();

obj.Has<MyComponent>(); // Returns true or false
obj.Has<IMyComponent>(); // Can also handle interfaces

obj.Get<MyComponent>(); // Returns the first component
obj.Get<IMyComponent>(); // Returns the first component that implements the interface

obj.GetAll<MyComponent>(); // Gets all the components
obj.GetAll<IMyComponent>(); // Gets all the components that implement the interface
[/code]

Another utility is for adding children to GameObjects:

[code lang="csharp"]
using UnityHelpers;

var obj = new GameObject();

obj.AddChild("Mike"); // Creates a new GameObject named "Mike" and adds it as a child

var player = obj.AddChild<Player>("Dave"); // Creates a new GameObject named "Dave" and adds the component "Player" returning it

obj.AddChild(typeof(Player), typeof(Friendly), typeof(AI)); // Creates a new GameObject and adds a number of components
[/code]

There are many other utils and extensions, and more to come.

Checkout the source for more info: [https://github.com/mikecann/Unity-Helpers/tree/master/Scripts](https://github.com/mikecann/Unity-Helpers/tree/master/Scripts)

I have rigorously unit and battle tested these utils and [added them to Github](https://github.com/mikecann/Unity-Helpers) so I can use them in furthur projects. I hope they can be of some use to others too!

As mentioned in my [previous post](https://www.mikecann.blog/games/taming-unity/) I have been working on a multiplayer game built in Unity for a little while now. I ummed and ahhed over the technology choice for the backend for a little while before deciding to go with [Parse.com](https://Parse.com)'s library. The reason being that it looked simple to implement (they have a Unity SDK), they take care of all the backend headaches for me and the pricing model looked fair.



The Parse Unity library is okay, not as fully fleshed as some of the other languages they support but good enough for what I needed apart from one critical point, the lack of type-safety in the queries such as:

[code language="csharp"]
new ParseQuery<Armor>().WhereLessThanOrEqualTo("cost", 13);
[/code]

This annoyed me so much that I decided to write some extension methods that take advantage of Lambda functions to provide the type-safety. The above now becomes:

[code language="csharp"]
new ParseQuery<Armor>().WhereLessThanOrEqualTo(a => a.Cost, 13);
[/code]

The library can also handle chains such as

[code language="csharp"]
new ParseQuery<Player>().Include(p => p.Stats.Heath.Remaining); // becomes "stats.health.remaining"
[/code]

The library also handles interfaces by introducing a new attribute "ParseFieldType".

[code language="csharp"][parseclassname("father")]
public class Father : ParseObject, IFather
{
[ParseFieldName("daughter")][parsefieldtype(typeof(child))]
public IChild Daughter { get; set; }
}

new ParseQuery<Father>().Include(f => f.Daughter.Name); // becomes "daughter.name" and works because ParseFieldType redirects the chain to Child rather than IChild
[/code]

It can even handle lists

[code language="csharp"][parseclassname("father")]
public class Father : ParseObject, IFather
{
[ParseFieldName("children")][parsefieldtype(typeof(child))]
public List<IChild> Children { get; set; }
}

new ParseQuery<Father>().Include(f => f.Children[0].Name); // becomes "children.name"
[/code]

To get started go grab the .dll from my Github project for the library: [https://github.com/mikecann/Unity-Parse-Helpers](https://github.com/mikecann/Unity-Parse-Helpers)