I decided to take a break from the [game development](https://www.mikecann.blog/myprojects/mr-nibbles-3d/mr-nibbles-3d-menus-obscuring/) today to scratch an itch I had had for a while.



Its no secret that im a fan of Entity-Component systems having used various flavours of them for years. My particular favourite however is found in [Richard Lord's Ash Framework](https://www.ashframework.org/). I have used it on numerous projects including my [3-game prototype challenge](/posts/the-three-game-challenge/).



Ash Framework however is written for the Flash platform. Though there are ports for other platforms, no one has yet done one for Unity. It gets talked about on the [Ash mailing list](https://groups.google.com/group/ash-framework?hl=en) every now and then but often dismissed as either impossible or pointless as Unity already has an Entity framework built into it.

Well after a [recent discussion](https://groups.google.com/forum/?hl=en#!topic/ash-framework/NrC5dQyBRkY) I decided I wanted to have a go at it anyway. It turns out its actually not that hard to implement.

Starting off with [David Arno's .Net port of Ash](https://github.com/DavidArno/Ash.NET) I wrote two small classes that wrap the [Ash Engine](https://github.com/mikecann/UnityAshteroids/blob/master/Assets/Ash/Unity/AshGame.cs) and [Ash Entity](https://github.com/mikecann/UnityAshteroids/blob/master/Assets/Ash/Unity/AshEntity.cs).

Ash Entity is the key piece to the puzzle. You add it as a component to your game object:

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

It then checks to see which Unity components have been added or removed each frame and updates the Ash Entity reference. Its simple but it works! It even includes the default Unity Components so that means you don't need a base "AshComponent".

The AshEngine serves as the root of the hierarchy. So long as you place entities below it they will be able to find the engine. This makes it really easy and convenient to create scenes at design time and have them work when you hit play:

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

From that simple foundation I decided to have a go at porting the entire of Richard's Asteroids example over to Unity. I was surprised at how little issues I ran into. You can give it a play here:

[/projects/UnityAshteroids/UnityAshteroids.html](/projects/UnityAshteroids/UnityAshteroids.html)
**Use arrow keys to move and space to shoot.**

It all works surprisingly well. [The code](https://github.com/mikecann/UnityAshteroids) is really clean and very simmilar to the original.

The only changes I needed to make from the .Net port was to change some "internals" to "public" and changed the type of the update variable from double to float as Unity uses floats for everything not doubles.

Instead of manually defining the components in "EntityCreator" I use Unity's prefab system which makes it really nice and easy to edit properties in the inspector in the editor:

[![screenshot_004](https://www.mikecann.blog/wp-content/uploads/2014/07/screenshot_004-1024x685.png)](https://www.mikecann.blog/wp-content/uploads/2014/07/screenshot_004.png)

Then load them the usual Unity way using Resources.Load().

Systems are just pure code and added to the Engine as usual:

[code lang="csharp"]
public class Asteroids : AshGame
{
private EntityCreator creator;
private GameConfig config;

    void Awake()
    {
    	creator = new EntityCreator(this);
    	config = new GameConfig();

    	var size = Camera.main.ScreenToWorldPoint(new Vector2(Screen.width, Screen.height));
    	config.Bounds = new Bounds(Vector3.zero, new Vector3(size.x*2, size.y*2));

    	Engine.AddSystem(new WaitForStartSystem(creator), SystemPriorities.PreUpdate);
    	Engine.AddSystem(new GameManagerSystem(creator, config), SystemPriorities.PreUpdate);
    	Engine.AddSystem(new MotionControlSystem(), SystemPriorities.Update);
    	Engine.AddSystem(new GunControlSystem(creator), SystemPriorities.Update);
    	Engine.AddSystem(new BulletAgeSystem(creator), SystemPriorities.Update);
    	Engine.AddSystem(new DeathThroesSystem(creator), SystemPriorities.Update);
    	Engine.AddSystem(new MovementSystem(config), SystemPriorities.Move);
    	Engine.AddSystem(new CollisionSystem(creator), SystemPriorities.ResolveCollisions);
    	Engine.AddSystem(new HudSystem(), SystemPriorities.Animate);
    	Engine.AddSystem(new AudioSystem(), SystemPriorities.Render);

    	creator.CreateWaitForClick();
    	creator.CreateGame();
    }

}  
[/code]

The changes to the Asteroids code in general are minimal. I use Unity's components wherever possible, so things like Position and Movement become Transform and Rigidbody2D. Rendering is taken care of by Unity so I didn't need any RenderingSystem or Display component.

The code is available on GitHub for your perusal: [https://github.com/mikecann/UnityAshteroids](https://github.com/mikecann/UnityAshteroids)

I was actually surprised I was able to get this all working without any problems. There are improvements that could be made:

## Performance of AshEntity

AshEntity is the core to the whole thing and unfortunately it probably isn't the most performant. For each entity in the game it checks every frame to see if any components were added or removed. It doesn't do this in the best possible way so there is definitely room to improve this.

## Sugar

There is plenty of room for syntax sugar thanks to the superior C# language over Actionscript 3\. NodeList could be made generic and a generic ListIteratingSystem could be developed and perhaps even a way of eliminating nodes altogether. Also retrieving components from Ash Entity could be made simpler by removing the need to pass in the type param when calling Entity.Get<>().

## Finite State Machines

As the .Net port does not include Richard's FSM code I worked around the problem by destroying and creating new prefabs. This works quite well as it allows you to use the inspector to visually design the prefabs however a nice addition would be some editor tools and code for FSMs in Unity.

## Unit Tests

I copied over the .Net tests from David's port and got them running in unity using Unity Test tools without any problems however my Ash Unity code isn't tested. There isn't much of it but it probably should be covered.

This is my first post of what I suspect will be many on the subject of SWFt.

What is SWFt I hear you cry? Well in a nut shell SWFt is an Entity-Component based game framework powered by Dependency Injection. Still confused? Well basically its a really nice neat method for making flash games. Still interested? Read on!



First the history, if you arent interested in this then just skip on down to "What exactly is it?"

**History**

It started off as an idea I had while playing around with some RobotLegs code. For those not in the know, [RobotLegs ](https://www.robotlegs.org/) (RL) is an awsome Inversion of Control (IoC) or Dependency Injection (DI) MVCS framework for making Rich Internet Applications (I wrote a post on it [here](/posts/on-the-bleeding-edge/)). IoC and DI were new concepts to me and I was fascinated and excited by the power that they had especially when couppled with something like [AS3 Signals](https://github.com/robertpenner/as3-signals).

At the time of this discovery I was working on a game that used [Push Button Engine](https://pushbuttonengine.com/) (PBE) and [Mate ](https://mate.asfusion.com/)as the basis for development. Feeling dissatisfied with PBE and Mate I wondered if there was a way I could take all the cool things I was playing around with RobotLegs and apply them to some of the cool aspects of PBE.

The first thing I did was to check to see if anyone else has had the idea of using DI in a component based game engine. It looked like it hasnt been done in AS3 but it looks like it has already been thought about and documented in Java. There has been a paper written about it here: [https://portal.acm.org/citation.cfm?id=1658866.1658872](https://portal.acm.org/citation.cfm?id=1658866.1658872), I managed to get my greasy mitts on it and enjoyed the read however I think there was definitely room for improvement in AS3.

The next thing was to seek advice on whether it could even be done in RL. I decided that I should go straight to the source and I emailed one of the contributors to the RL project, Stray. It turns out stray is a very nice lady who is also from the north of the UK. She had some good words of advice but she recommendation that I repost my question to the RL mailing list where the other contributors to the project tend to lurk.

So I wrote up my query[ and posted it](https://groups.google.com/group/robotlegs/browse_thread/thread/f7e325c5caf14d93). I added in some diagrams of how I thought it may look:

[![](/wp-content/uploads/2010/06/Relationships-1-300x259.png "Relationships 1")](/wp-content/uploads/2010/06/Relationships-1.png)[![](/wp-content/uploads/2010/06/Example-1-300x161.png "Example 1")](/wp-content/uploads/2010/06/Example-1.png)

To cut a long story short, after [several months](https://groups.google.com/group/robotlegs/browse_thread/thread/4833ba99cd12b25a) of [posts](https://groups.google.com/group/robotlegs/browse_thread/thread/4d3eb6d8f8dd64bc#) back and forth with many excellent suggestions and contributions I felt it was time that the project migrated to its own home as not spam up the RL list too much. As such [SWft - Game Framework](https://groups.google.com/group/swft-framework) mailing list was born! Its still very new and as such there arent many posts yet but I hope for that to grow as the project progresses.

We also have a website: [https://www.swft.co.uk](https://www.swft.co.uk) but its meerly a holding page for now.

**What exactly is it?**

Okay so I promised I would talk about what SWFt actually is. Well without going into too much detail (more posts will follow that will flesh out examples etc) SWFt lets you make AS3 Flash games in a modular component based fashion like you do with [Push Button Engine](https://pushbuttonengine.com/) but it lets you keep the strict-type, compile-time checked game structure like you may find in [Flixel ](https://flixel.org/)or [Flash Punk](https://flashpunk.net/).

Its still very alpha and has alot more work left to do on it but you can follow progress on our GitHub page here: [https://github.com/mikecann/Swft](https://github.com/mikecann/Swft) and some examples can also be found here: [https://github.com/mikecann/Swift-Examples](https://github.com/mikecann/Swift-Examples) (the red-blue circle experiment is currently broken)

As I say, its still very early days, but I have been wanting to blog about it for a while as its a very exciting project im currently working on :)

**Contributions**

If you are interested in contributing code or thoughts or anything then shoot a message on the mailing list: [https://groups.google.com/group/swft-framework](https://groups.google.com/group/swft-framework)

Expect more posts in the coming weeks!

framwork

framwork

framwork