> 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!

[![](/wp-content/uploads/2012/06/robotlegsplushaxe.jpg "robotlegsplushaxe")](/wp-content/uploads/2012/06/robotlegsplushaxe.jpg)

I originally hoped that this post would be about my successful completion of a RobotLegs2 port to Haxe however something else has come up (more on that in a later post) so instead im just going to talk about the process and progress of the port thus far.



So although there is already [an excellent RobotLegs 1 Haxe port](https://github.com/DavidPeek/robothaxe) out there by David Peek, I decided I would like to try to port the brand new [Robot Legs 2 Framework](https://github.com/robotlegs/robotlegs-framework)  which offers a great many improvements over the original.

Rather than beginning the port from scratch I decided to use as3hx to take the legwork out of converting the AS3 code to Haxe code. To get the tool you must first checkout the library from its google code repo at: [https://caffeine-hx.googlecode.com/svn/trunk/projects/as3hx/](https://caffeine-hx.googlecode.com/svn/trunk/projects/as3hx/)

Once downloaded its just a simple matter of compiling the source into a neko executable:

```
haxe as3hx.hx
```

Then you can run it with:

```
neko as3hx.n
```

[![](/wp-content/uploads/2012/06/screenshot_01.gif "screenshot_01")](/wp-content/uploads/2012/06/screenshot_01.gif)

To convert a AS3 project give it an input and output folder:

```
neko as3hx.n -vector2array -uint2int robotlegs2 robotlegs2out
```

In this case the input folder is the source download from the [RobotLegs2 GitHub page](https://github.com/robotlegs/robotlegs-framework).

It will start to convert but will get stuck:

```
C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/api/IEventCommandMap.as
C:/Users/MikeC/Desktop/as3hx/robotlegs2out/robotlegs/bender/extensions/eventcommandmap/api/IEventCommandMap.hx
C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/impl/EventCommandExecutor.as
C:/Users/MikeC/Desktop/as3hx/robotlegs2out/robotlegs/bender/extensions/eventcommandmap/impl/EventCommandExecutor.hx
C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/impl/EventCommandFactory.as
C:/Users/MikeC/Desktop/as3hx/robotlegs2out/robotlegs/bender/extensions/eventcommandmap/impl/EventCommandFactory.hx
C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/impl/EventCommandMap.as
C:/Users/MikeC/Desktop/as3hx/robotlegs2out/robotlegs/bender/extensions/eventcommandmap/impl/EventCommandMap.hx
C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/impl/EventCommandTrigger.as
Called from ? line 1
Called from Run.hx line 66
Called from Run.hx line 55
Called from Run.hx line 55
Called from Run.hx line 55
Called from Run.hx line 55
Called from Run.hx line 55
Called from Run.hx line 55
Called from Run.hx line 38
Called from C:Motion-TwinHaxe/std/neko/Lib.hx line 63
Called from Run.hx line 29
Called from as3hx/Parser.hx line 117
Called from as3hx/Parser.hx line 131
Called from as3hx/Parser.hx line 488
Called from as3hx/Parser.hx line 415
Called from as3hx/Parser.hx line 589
Called from as3hx/Parser.hx line 794
Called from as3hx/Parser.hx line 744
Called from as3hx/Parser.hx line 919
Called from as3hx/Parser.hx line 964
Called from as3hx/Parser.hx line 1106
Called from as3hx/Parser.hx line 1016
Called from as3hx/Parser.hx line 1075
Called from as3hx/Parser.hx line 1179
Called from as3hx/Parser.hx line 330
Called from as3hx/Parser.hx line 1003
Uncaught exception - In C:/Users/MikeC/Desktop/as3hx/robotlegs2/src/robotlegs/bender/extensions/eventCommandMap/impl/Eve
ntCommandTrigger.as(75) : Unexpected .
```

It seems like as3hx is getting confused around this line in the AS3 source:

```haxe
if (describeType(mapping.commandClass).factory.method.(@name == "execute").length() == 0)
throw new Error("Command Class must expose an execute method");
```

It looks like a bit of E4X is confusing the script. To solve this sort of problem I made a note of the location and file and just commented the offending line out. This allows as3hx to get past that particular snag. After going through this process a few times the project should be fully converted.

From there I setup a project in FlashDevelop and tried to compile. After fixing a few things that as3hx couldnt solve I came accross a rather major stumbling block.

RobotLegs2 unlike RL1 has a strong dependency on the dependency injection container SwiftSuspenders. So to get RL to compile I first need to port SwiftSupenders2.

So I repeated the process above but for SwiftSuspenders. Eventually this left me with a whole load of broken unit tests. Till Schneidereit the (rather splendid) author of SwiftSuspenders wrote a great number of unit tests for the library, which is one of the reasons why its so excellent. So I knew that to achieve a proper port all I need do is pass all those tests and I can then be confident that the code is solid.

After a few evenings of toil I managed to get 50 tests to pass in the Flash target. This is quite abit shy of the 160+ tests in the original AS3 version of the library, however a great many of those tests are not relevant to Haxe such as ArrayCollection tests, XML tests and DescribeType tests. I also decided for now to remove all of the event dispatching (and thus their tests) code from the library for now due to their dependency on the Flash platform. Despite this I think the 50 tests that do pass are probably representative of the core functionality of the library.

With the Flash target passing I indented to then move onto passing the tests in the other targets (JS, C++, php etc). I was hoping that with the flash part passing that they would all pass considering that im using the inbuilt haxe reflection methods not any platform specific reflection, but alas this was not to be the case. Starting with the JS target I started to get alot of errors on some of the basic Injector tests. After some digging in the compiled JS source I traced it back to an issue in the Meta Data generation for the @Inject tag on the JS target.

Unfortunately, I have run out of time on this little side project for now so am going to have to park it. I have uploaded the progress thus far to GitHub should anyone else wish to take up the mantle on the port:

[https://github.com/mikecann/SwiftSuspendersHx](https://github.com/mikecann/SwiftSuspendersHx)
[https://github.com/mikecann/RobotLegs2Hx](https://github.com/mikecann/RobotLegs2Hx)

I had indented, once everything was passing, was to do a branch of the project and incorporate some features that only the Haxe language can support. Features such as proper generics and macros would bring some added awesome.