diff --git a/Core/Game/Abilities/Ability.cs b/Core/Game/Abilities/Ability.cs
index 3cfff71c..8f0ef4da 100644
--- a/Core/Game/Abilities/Ability.cs
+++ b/Core/Game/Abilities/Ability.cs
@@ -6,58 +6,37 @@
 //=======================================================================
 using UnityEngine;
 using Lockstep.Data;
-
-namespace Lockstep
-{
+namespace Lockstep {
     public abstract class Ability : CerealBehaviour
     {
         private bool isCasting;
         
-        private LSAgent _agent;
-
-        public LSAgent Agent
-        {
-            get
-            {
+		private LSAgent _agent;
+		public LSAgent Agent {
+			get {
 #if UNITY_EDITOR
-                if (_agent == null)
-                    return this.GetComponent<LSAgent>();
+				if (_agent == null) return this.GetComponent<LSAgent> ();
 #endif
-                return _agent;
-            }
-        }
-
-        public string MyAbilityCode { get; private set; }
-
-        public AbilityInterfacer Interfacer { get; private set; }
-
-        public int ID { get; private set; }
-
-        public Transform CachedTransform { get { return Agent.CachedTransform; } }
-
-        public GameObject CachedGameObject { get { return Agent.CachedGameObject; } }
-
-        public int VariableContainerTicket { get; private set; }
-
-        private LSVariableContainer _variableContainer;
-
-        public LSVariableContainer VariableContainer { get { return _variableContainer; } }
-
-        public bool IsCasting
-        {
-            get
-            {
-                return isCasting;
-            }
-            protected set
-            {
-                if (value != isCasting)
-                {
-                    if (value == true)
-                    {
+				return _agent;
+			}
+		}
+        public string MyAbilityCode {get; private set;}
+        public AbilityInterfacer Interfacer {get; private set;}
+
+		public int ID {get; private set;}
+		public Transform CachedTransform {get {return Agent.CachedTransform;}}
+		public GameObject CachedGameObject {get {return Agent.CachedGameObject;}}
+        public int LSVariableContainerTicket {get; private set;}
+
+        public bool IsCasting {
+            get {
+				return isCasting;
+			}
+            protected set {
+                if (value != isCasting) {
+                    if (value == true) {
                         Agent.CheckCasting = false;
-                    } else
-                    {
+                    } else {
                         Agent.CheckCasting = true;
                     }
                     isCasting = value;
@@ -67,116 +46,77 @@ protected set
 
 
 
-        internal void Setup(LSAgent agent, int id)
-        {
+        public void Setup(LSAgent agent, int id) {
             System.Type mainType = this.GetType();
-            if (mainType.IsSubclassOf(typeof(ActiveAbility)))
-            {
-                while ( mainType.BaseType != typeof(ActiveAbility))
-                {
-                    mainType = mainType.BaseType;
-                }
-                Interfacer = AbilityInterfacer.FindInterfacer(mainType);
 
-                if (Interfacer == null)
-                {
-                    throw new System.ArgumentException("The Ability of type " + mainType + " has not been registered in database");
-                }
-                this.MyAbilityCode = Interfacer.Name;
-            } else
-            {
-                this.MyAbilityCode = mainType.Name;
+            while (mainType.BaseType != typeof (Ability) && mainType.BaseType != typeof (ActiveAbility)) {
+                mainType = mainType.BaseType;
+            }
+            Interfacer = AbilityInterfacer.FindInterfacer(mainType);
+            if (Interfacer == null) {
+                throw new System.ArgumentException("The Ability of type " + mainType + " has not been registered in database");
             }
+            this.MyAbilityCode = Interfacer.Name;
             _agent = agent;
-            ID = id;
-            TemplateSetup();
+			ID = id;
+			TemplateSetup ();
             OnSetup();
-            this.VariableContainerTicket = LSVariableManager.Register(this);
-            this._variableContainer = LSVariableManager.GetContainer(VariableContainerTicket);
+            this.LSVariableContainerTicket = LSVariableManager.Register(this);
         }
 
-        protected virtual void TemplateSetup()
-        {
+		protected virtual void TemplateSetup () {
 
-        }
+		}
 
-        protected virtual void OnSetup()
-        {
-        }
+        protected virtual void OnSetup() {}
 
-        internal void Initialize()
-        {
-            VariableContainer.Reset();
+        public void Initialize() {
             IsCasting = false;
             OnInitialize();
         }
 
-        protected virtual void OnInitialize()
-        {
-        }
+        protected virtual void OnInitialize() {}
 
-        internal void Simulate()
-        {
+        public void Simulate() {
             OnSimulate();
-            if (isCasting)
-            {
+            if (isCasting) {
                 OnCast();
             }
         }
+        protected virtual void OnSimulate() {}
 
-        protected virtual void OnSimulate()
-        {
-        }
+		public void LateSimulate () {
+			OnLateSimulate ();
+		}
+		protected virtual void OnLateSimulate () {
 
-        internal void LateSimulate()
-        {
-            OnLateSimulate();
-        }
+		}
 
-        protected virtual void OnLateSimulate()
-        {
+        protected virtual void OnCast() {}
 
-        }
-
-        protected virtual void OnCast()
-        {
-        }
-
-        internal void Visualize()
-        {
+        public void Visualize() {
             OnVisualize();
         }
 
-        protected virtual void OnVisualize()
-        {
-        }
+        protected virtual void OnVisualize() {}
 
-        public void BeginCast()
-        {
+        public void BeginCast() {
             OnBeginCast();
         }
 
-        protected virtual void OnBeginCast()
-        {
-        }
+        protected virtual void OnBeginCast() {}
 
-        public void StopCast()
-        {
+        public void StopCast() {
             OnStopCast();
         }
 
-        protected virtual void OnStopCast()
-        {
-        }
+        protected virtual void OnStopCast() {}
 
-        public void Deactivate()
-        {
+        public void Deactivate() {
             IsCasting = false;
             OnDeactivate();
         }
 
-        protected virtual void OnDeactivate()
-        {
-        }
+        protected virtual void OnDeactivate() {}
     }
 }
\ No newline at end of file
diff --git a/Core/Game/Abilities/ActiveAbility.cs b/Core/Game/Abilities/ActiveAbility.cs
index c609312b..7ef077f3 100644
--- a/Core/Game/Abilities/ActiveAbility.cs
+++ b/Core/Game/Abilities/ActiveAbility.cs
@@ -3,11 +3,11 @@
 namespace Lockstep {
     public abstract class ActiveAbility : Ability {
 
-		public ushort ListenInput {get; private set;}
+		public InputCode ListenInput {get; private set;}
 
 		protected sealed override void TemplateSetup ()
 		{
-            ListenInput = Interfacer.ListenInputID;
+			ListenInput = Interfacer.ListenInput;
 		}
 
         public void Execute(Command com) {
diff --git a/Core/Game/Abilities/BehaviourHelper/BehaviourHelper.cs b/Core/Game/Abilities/BehaviourHelper/BehaviourHelper.cs
index 5d84f373..8f1f6ef8 100644
--- a/Core/Game/Abilities/BehaviourHelper/BehaviourHelper.cs
+++ b/Core/Game/Abilities/BehaviourHelper/BehaviourHelper.cs
@@ -3,104 +3,76 @@
 using Lockstep;
 using System.Collections.Generic;
 using System;
-
 public abstract class BehaviourHelper : MonoBehaviour, IBehaviourHelper
 {
 
-    public BehaviourHelper()
-    {
-
-    }
-
-    private static FastList<BehaviourHelper> behaviourHelpers = new FastList<BehaviourHelper>();
-    private static HashSet<Type> createdTypes = new HashSet<Type>();
-
-    public ushort CachedListenInput {get; private set;}
+    public BehaviourHelper () {
 
-    public virtual ushort ListenInput
-    {
-        get { return 0; }
     }
 
-    public void Initialize()
-    {
-        CachedListenInput = ListenInput;
-        OnInitialize();
-    }
+	private static FastList<BehaviourHelper> behaviourHelpers = new FastList<BehaviourHelper> ();
+	private static HashSet<Type> createdTypes = new HashSet<Type> ();
+	
 
-    protected virtual void OnInitialize()
-    {
+	public virtual InputCode ListenInput {
+        get {return InputCode.None;}
     }
 
-    public void LateInitialize()
-    {
+	public void Initialize ()
+	{
+		OnInitialize ();
+	}
+	
+	protected virtual void OnInitialize ()
+	{
+	}
+    public void LateInitialize () {
         this.OnLateInitialize();
     }
-
-    protected virtual void OnLateInitialize()
-    {
-
-    }
-
-    public void Simulate()
-    {
-        OnSimulate();
-    }
-
-    protected virtual void OnSimulate()
-    {
-    }
-
-    public void LateSimulate()
-    {
-        OnLateSimulate();
-    }
-
-    protected virtual void OnLateSimulate()
-    {
-
-    }
-
-    public void Visualize()
-    {
-        OnVisualize();
-    }
-
-    protected virtual void OnVisualize()
-    {
-    }
-
-    public void Execute(Command com)
-    {
-        OnExecute(com);
-    }
-
-    protected virtual void OnExecute(Command com)
-    {
-    }
-
-    public void RawExecute (Command com) {
-        OnRawExecute (com);
-    }
-    protected virtual void OnRawExecute (Command com) {
-
-    }
-
-    public void GameStart () {
-        OnGameStart ();
-    }
-
-    protected virtual void OnGameStart () {
-
-    }
-
-    public void Deactivate()
-    {
-        OnDeactivate();
-    }
-
-    protected virtual void OnDeactivate()
-    {
+    protected virtual void OnLateInitialize () {
+
+    }
+    public void Simulate ()
+	{
+		OnSimulate ();
+	}
+	
+	protected virtual void OnSimulate ()
+	{
+	}
+    public void LateSimulate () {
+        OnLateSimulate ();
+    }
+    protected virtual void OnLateSimulate (){
+
+    }
+	
+    public void Visualize ()
+	{
+		OnVisualize ();
+	}
+	
+	protected virtual void OnVisualize ()
+	{
+	}
+	
+    public void Execute (Command com)
+	{
+		OnExecute (com);
+	}
+	
+	protected virtual void OnExecute (Command com)
+	{
+	}
+	
+    public void Deactivate ()
+	{
+			OnDeactivate ();
+	}
+	
+	protected virtual void OnDeactivate ()
+	{
 		
-    }
+		
+	}
 }
\ No newline at end of file
diff --git a/Core/Game/Abilities/BehaviourHelper/BehaviourHelperManager.cs b/Core/Game/Abilities/BehaviourHelper/BehaviourHelperManager.cs
index 3e5adb49..90088d5c 100644
--- a/Core/Game/Abilities/BehaviourHelper/BehaviourHelperManager.cs
+++ b/Core/Game/Abilities/BehaviourHelper/BehaviourHelperManager.cs
@@ -18,12 +18,6 @@ public static void LateInitialize () {
             }
         }
 
-        public static void GameStart () {
-            foreach (var helper in Helpers) {
-                helper.GameStart();
-            }
-        }
-
         public static void Simulate () {
             foreach (BehaviourHelper helper in Helpers) {
                 helper.Simulate ();
@@ -38,10 +32,9 @@ public static void LateSimulate () {
 
         public static void Execute (Command com) {
             foreach (BehaviourHelper helper in Helpers) {
-                if (helper.CachedListenInput == com.LeInput) {
+                if (helper.ListenInput == com.LeInput) {
                     helper.Execute (com);
                 }
-                helper.RawExecute(com);
             }
         }
 
diff --git a/Core/Simulation/Math/Pan-Line-Algorithm.meta b/Core/Game/Abilities/BuildAbil.meta
similarity index 67%
rename from Core/Simulation/Math/Pan-Line-Algorithm.meta
rename to Core/Game/Abilities/BuildAbil.meta
index 5528fd62..ce6ce64f 100644
--- a/Core/Simulation/Math/Pan-Line-Algorithm.meta
+++ b/Core/Game/Abilities/BuildAbil.meta
@@ -1,7 +1,7 @@
 fileFormatVersion: 2
-guid: 615fb633fad344682aca5d2d92a83eb5
+guid: f6f80e1c64dfa4d279adedd519dad128
 folderAsset: yes
-timeCreated: 1451067379
+timeCreated: 1442625300
 licenseType: Pro
 DefaultImporter:
   userData: 
diff --git a/Core/Game/Abilities/BuildAbil/Build.cs b/Core/Game/Abilities/BuildAbil/Build.cs
new file mode 100644
index 00000000..2963b16e
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/Build.cs
@@ -0,0 +1,48 @@
+using UnityEngine;
+using System.Collections;
+
+namespace Lockstep
+{
+	public class Build : ActiveAbility
+	{
+		[SerializeField]
+		private BuildNode[] _tiles;
+		public BuildNode[] Tiles {get {return _tiles;}}
+
+		public bool Disabled {get; set;}
+
+		protected override void OnSetup ()
+		{
+			for (ushort i = 0; i < Tiles.Length; i++) {
+				Tiles[i].Setup (i, this);
+			}
+
+		}
+
+		protected override void OnInitialize ()
+		{
+			for (int i = 0; i < Tiles.Length;i ++) {
+				Tiles[i].Initialize();
+			}
+			Disabled = false;
+            /*foreach (BuildNode node in _tiles) {
+                node.SendBuild(1);
+            }*/
+		}
+
+		protected override void OnExecute (Command com)
+		{
+			if (com.HasCount && com.HasTarget)
+			{
+				Tiles[com.Target].Execute (com);
+			}
+		}
+#if UNITY_EDITOR
+        protected override void OnAfterSerialize  ()
+		{
+			BuildNode[] tempTiles = Agent.GetComponentsInChildrenOrderered<BuildNode> ();
+			if (tempTiles .IsNotNull ()) _tiles = tempTiles;
+		}
+#endif
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/BackwardsCommand.cs.meta b/Core/Game/Abilities/BuildAbil/Build.cs.meta
similarity index 75%
rename from Core/Game/Player/Commands/BackwardsCommand.cs.meta
rename to Core/Game/Abilities/BuildAbil/Build.cs.meta
index 8128dd25..f80b88fc 100644
--- a/Core/Game/Player/Commands/BackwardsCommand.cs.meta
+++ b/Core/Game/Abilities/BuildAbil/Build.cs.meta
@@ -1,6 +1,6 @@
 fileFormatVersion: 2
-guid: 9641815bce2ca4e15b97ae138609a4f2
-timeCreated: 1451677754
+guid: c649ae167a6174026949df8e16b8ba4c
+timeCreated: 1442352430
 licenseType: Pro
 MonoImporter:
   serializedVersion: 2
diff --git a/Core/Game/Abilities/BuildAbil/BuildManager.cs b/Core/Game/Abilities/BuildAbil/BuildManager.cs
new file mode 100644
index 00000000..ccbbfb30
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildManager.cs
@@ -0,0 +1,31 @@
+using UnityEngine;
+using System.Collections;
+using Lockstep;
+public static class BuildManager {
+    public static void Visualize () {
+        BuildNode buildNode;
+        if (InputManager.GetInformationDown ()) {
+
+        }
+        if (Interfacing.CachedDidHit)
+        {
+            if (Interfacing.MousedObject.tag == "BuildTile")
+            {/*
+                if (InputManager.GetInformationDown())
+                {
+                    CurrentBuildTile = Interfacing.MousedObject.GetComponent<BuildNode>();
+                    if (CurrentBuildTile.CanBuild == false)
+                    {
+                        CurrentBuildTile = null;
+                    } else
+                    {
+                        if (CurrentBuildTile.Agent.Controllable)
+                        {
+                            GUIManager.EnvironmentUI.BuildingMenu.Open(CurrentBuildTile);
+                        }
+                    }
+                }*/
+            }
+        }
+    }
+}
diff --git a/Core/Game/Managers/Input/InputCodeManager.cs.meta b/Core/Game/Abilities/BuildAbil/BuildManager.cs.meta
similarity index 75%
rename from Core/Game/Managers/Input/InputCodeManager.cs.meta
rename to Core/Game/Abilities/BuildAbil/BuildManager.cs.meta
index dfed0a15..5751d1ab 100644
--- a/Core/Game/Managers/Input/InputCodeManager.cs.meta
+++ b/Core/Game/Abilities/BuildAbil/BuildManager.cs.meta
@@ -1,6 +1,6 @@
 fileFormatVersion: 2
-guid: 67093f6f3e6244268b1f69ea9966972e
-timeCreated: 1451427394
+guid: 002aed10254514e258572af0e241a59c
+timeCreated: 1446832266
 licenseType: Pro
 MonoImporter:
   serializedVersion: 2
diff --git a/Core/Game/Abilities/BuildAbil/BuildMenu.cs b/Core/Game/Abilities/BuildAbil/BuildMenu.cs
new file mode 100644
index 00000000..5aee1b7b
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildMenu.cs
@@ -0,0 +1,57 @@
+using UnityEngine;
+using System.Collections;
+using UnityEngine.UI;
+using Lockstep;
+public class BuildMenu : CerealBehaviour {
+	private LSUIWindow window;
+	public BuildNode CurrentBuildNode {get; private set;}
+	[SerializeField]
+	private BuildMenuTile[] _tiles;
+	BuildMenuTile[] Tiles {get {return _tiles;}}
+	private static BuildMenu instance;
+	public void Setup () {
+		window = GetComponent<LSUIWindow> ();
+		instance = this;
+		for (int i = 0; i < _tiles.Length; i++) {
+			_tiles[i].Setup (i);
+		}
+	}
+	public void Initialize () {
+		StartCoroutine (StartClose ());
+    }
+	IEnumerator StartClose () {
+		yield return null;
+		Close ();
+	}
+	public void Open (BuildNode node)
+	{
+
+		CurrentBuildNode = node;
+		window.Show ();
+
+		for (int i = 0; i < node.SpawnableAgents.Length; i++) {
+			Tiles[i].Open (node.SpawnableAgents[i]);
+		}
+	}
+	public void Close () {
+		window.Hide ();
+		foreach (BuildMenuTile tile in Tiles) {
+			tile.Close ();
+		}
+
+	}
+	public static void Press (int index) {
+		instance.LocalPress (index);
+	}
+	private void LocalPress (int index) {
+		CurrentBuildNode.SendBuild (index);
+		Close ();
+	}
+
+#if UNITY_EDITOR
+    protected override void OnAfterSerialize  ()
+	{
+		_tiles = this.GetComponentsInChildrenOrderered<BuildMenuTile> () ?? _tiles;
+	} 
+#endif
+}
diff --git a/Core/Game/Player/Commands/Default/BaseSerializableValue.cs.meta b/Core/Game/Abilities/BuildAbil/BuildMenu.cs.meta
similarity index 75%
rename from Core/Game/Player/Commands/Default/BaseSerializableValue.cs.meta
rename to Core/Game/Abilities/BuildAbil/BuildMenu.cs.meta
index 21425307..7015d78d 100644
--- a/Core/Game/Player/Commands/Default/BaseSerializableValue.cs.meta
+++ b/Core/Game/Abilities/BuildAbil/BuildMenu.cs.meta
@@ -1,6 +1,6 @@
 fileFormatVersion: 2
-guid: 2e109c9a7def0460faf8705eb304cddf
-timeCreated: 1451622839
+guid: cd5bddb94befd42d3a9ff0bdfab9f58c
+timeCreated: 1442352555
 licenseType: Pro
 MonoImporter:
   serializedVersion: 2
diff --git a/Core/Game/Abilities/BuildAbil/BuildMenuTile.cs b/Core/Game/Abilities/BuildAbil/BuildMenuTile.cs
new file mode 100644
index 00000000..1aeadcc7
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildMenuTile.cs
@@ -0,0 +1,51 @@
+using UnityEngine;
+using System.Collections;
+using Lockstep;
+using UnityEngine.UI;
+using Lockstep.Data;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+namespace Lockstep
+{
+	public class BuildMenuTile : CerealBehaviour
+	{
+		[SerializeField]
+		private Image _image;
+		Image Imager {get{return _image;}}
+		[SerializeField]
+		private Button _button;
+		Button Buttoner {get {return _button;}}
+		[SerializeField]
+		private Text _text;
+		Text Texter {get {return _text;}}
+
+		public int ID {get; private set;}
+		public void Setup (int id) {
+			this.ID = id;
+			if (Buttoner.IsNotNull ())
+			_button.onClick.AddListener(Press);
+		}
+
+
+		public void Open (string agentCode) {
+			AgentInterfacer agentInfo = AgentController.GetAgentInterfacer (agentCode);
+			Imager.sprite = agentInfo.Icon;
+			Texter.text = agentCode.ToString ();
+			gameObject.SetActiveIfNot (true);
+		}
+		public void Close () {
+			gameObject.SetActiveIfNot (false);
+		}
+		public void Press () {
+			BuildMenu.Press(ID);
+		}
+#if UNITY_EDITOR
+        protected override void OnAfterSerialize  () {
+			_image = _image ?? this.GetComponentInChildrenOrderered<Image> ();
+			_button = _button ?? this.GetComponentInChildrenOrderered<Button> ();
+			_text = _text ?? this.GetComponentInChildrenOrderered<Text> ();
+		}
+#endif
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Default/DefaultData.cs.meta b/Core/Game/Abilities/BuildAbil/BuildMenuTile.cs.meta
similarity index 75%
rename from Core/Game/Player/Commands/Default/DefaultData.cs.meta
rename to Core/Game/Abilities/BuildAbil/BuildMenuTile.cs.meta
index 5ab1316e..6ed38529 100644
--- a/Core/Game/Player/Commands/Default/DefaultData.cs.meta
+++ b/Core/Game/Abilities/BuildAbil/BuildMenuTile.cs.meta
@@ -1,6 +1,6 @@
 fileFormatVersion: 2
-guid: 6b2894230349247dd9e3ba4a376e9c06
-timeCreated: 1451674605
+guid: 47e2effbf4aff4b07a6839d2343d82b9
+timeCreated: 1442621639
 licenseType: Pro
 MonoImporter:
   serializedVersion: 2
diff --git a/Core/Game/Abilities/BuildAbil/BuildNode.cs b/Core/Game/Abilities/BuildAbil/BuildNode.cs
new file mode 100644
index 00000000..206cfa5d
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildNode.cs
@@ -0,0 +1,73 @@
+ using UnityEngine;
+using System.Collections;
+using Lockstep.Data;
+using Lockstep;
+using System;
+public class BuildNode : CerealBehaviour, IMousable {
+
+    Vector3 IMousable.WorldPosition {
+        get {
+            return transform.position;
+        }
+    }
+    float IMousable.MousableRadius { get {return (float)(int)this._nodeType / 2;}}
+
+	[SerializeField]
+	private Vector2dHeight _localPos;
+
+	[SerializeField,DataCode ("Agents")]
+	private string[] _spawnableAgents;
+	public string[] SpawnableAgents {get {return _spawnableAgents;}}
+
+    [SerializeField]
+    private BuildNodeType _nodeType;
+    public BuildNodeType NodeType {get{return _nodeType;}}
+
+	public bool CanBuild {get {return Builder != null && Builder.Disabled == false && Occupied == false;}}
+	public bool Occupied {get ;private set;}
+	public ushort ID {get; private set;}
+	private Build Builder;
+	public LSAgent Agent {get {return Builder .IsNotNull () ? Builder.Agent : null;}}
+	public void Setup (ushort id, Build build)
+	{
+		ID = id;
+		Builder = build;
+	}
+	public void Initialize () {
+		Occupied = false;
+	}
+	public void SendBuild (int creationIndex ) {
+		Command com = new Command (InputCode.Build, Agent.Controller.ControllerID);
+		com.Target = ID;
+		com.Count = creationIndex;
+		com.Select = new Selection();
+		LSUtility.bufferAgents.FastClear ();
+		LSUtility.bufferAgents.Add (Builder.Agent);
+		com.Select.Serialize (LSUtility.bufferAgents);
+		CommandManager.SendCommand (com);
+	}
+
+	public void Execute (Command com)
+	{
+		if (CanBuild == false) return;
+		LSAgent agent = Agent.BuildChild (SpawnableAgents[com.Count], _localPos.ToOrientedVector2d (), _localPos.Height);
+		agent.onDeactivation += OnChildDie;
+		Occupied = true;
+	}
+
+    Action<LSAgent> _onChildDie;
+    Action<LSAgent> _OnChildDie {get {return _onChildDie ?? (_onChildDie = OnChildDie);}}
+	private void OnChildDie (LSAgent agent) {
+		agent.onDeactivation -= OnChildDie;
+		//Occupied = false;
+	}
+#if UNITY_EDITOR
+
+    protected override void OnAfterSerialize  () {
+		Vector3 localPos = transform.root.InverseTransformPoint (transform.position);
+		_localPos = new Vector2dHeight(localPos);
+
+		new UnityEditor.SerializedObject (this).ApplyModifiedProperties ();
+	}
+#endif
+}
diff --git a/Core/Game/Abilities/BuildAbil/BuildNode.cs.meta b/Core/Game/Abilities/BuildAbil/BuildNode.cs.meta
new file mode 100644
index 00000000..8a68548c
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildNode.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cb195171565e2489c920b5148b0e02f5
+timeCreated: 1442352722
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Abilities/BuildAbil/BuildNodeType.cs b/Core/Game/Abilities/BuildAbil/BuildNodeType.cs
new file mode 100644
index 00000000..064320ef
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildNodeType.cs
@@ -0,0 +1,5 @@
+public enum BuildNodeType : int{
+    Regular = 1,
+    Medium = 2,
+    Large = 3,
+}
\ No newline at end of file
diff --git a/Core/Game/Abilities/BuildAbil/BuildNodeType.cs.meta b/Core/Game/Abilities/BuildAbil/BuildNodeType.cs.meta
new file mode 100644
index 00000000..6eff79ae
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/BuildNodeType.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1652c6a3cd64b4c70982d0a84556d810
+timeCreated: 1446832342
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab b/Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab
new file mode 100644
index 00000000..77e57770
--- /dev/null
+++ b/Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab
@@ -0,0 +1,127 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &145296
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 413738}
+  - 114: {fileID: 11476858}
+  m_Layer: 0
+  m_Name: RegularBuildNode
+  m_TagString: BuildTile
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &188114
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 457258}
+  - 33: {fileID: 3305516}
+  - 23: {fileID: 2315090}
+  m_Layer: 0
+  m_Name: socket4adv
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &413738
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 145296}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 1.39999998, y: 1.13, z: -6.38000011}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 457258}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+--- !u!4 &457258
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 188114}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 24, y: 24, z: 24}
+  m_Children: []
+  m_Father: {fileID: 413738}
+  m_RootOrder: 0
+--- !u!23 &2315090
+MeshRenderer:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 188114}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 5387990d0fc544863b5ac6c2033705ad, type: 2}
+  m_SubsetIndices: 
+  m_StaticBatchRoot: {fileID: 0}
+  m_UseLightProbes: 1
+  m_ReflectionProbeUsage: 1
+  m_ProbeAnchor: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_ImportantGI: 0
+  m_AutoUVMaxDistance: .5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+--- !u!33 &3305516
+MeshFilter:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 188114}
+  m_Mesh: {fileID: 4300000, guid: 32db71e6c5e554f2cb716ed4a7dc3935, type: 3}
+--- !u!114 &11476858
+MonoBehaviour:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 145296}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cb195171565e2489c920b5148b0e02f5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  _localPos:
+    _x: 0
+    _y: 0
+    _height: 0
+  _spawnableAgents: 0100000002000000
+  _nodeType: 0
+--- !u!1001 &100100000
+Prefab:
+  m_ObjectHideFlags: 1
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 0}
+      propertyPath: m_IsKinematic
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_UseGravity
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 0}
+  m_RootGameObject: {fileID: 145296}
+  m_IsPrefabParent: 1
diff --git a/Resources/DefaultLockstepFrameworkSettings.asset.meta b/Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab.meta
similarity index 64%
rename from Resources/DefaultLockstepFrameworkSettings.asset.meta
rename to Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab.meta
index 144e5bbd..5bd0439d 100644
--- a/Resources/DefaultLockstepFrameworkSettings.asset.meta
+++ b/Core/Game/Abilities/BuildAbil/RegularBuildNode.prefab.meta
@@ -1,6 +1,6 @@
 fileFormatVersion: 2
-guid: 500ed74871c8949fd8ab0dd3e91259a8
-timeCreated: 1451867258
+guid: 36b30355eb35c4f689aa9a9cfa70a065
+timeCreated: 1442789450
 licenseType: Pro
 NativeFormatImporter:
   userData: 
diff --git a/Core/Game/Abilities/Essential/Move.cs b/Core/Game/Abilities/Essential/Move.cs
index 28ef699a..892eb02c 100644
--- a/Core/Game/Abilities/Essential/Move.cs
+++ b/Core/Game/Abilities/Essential/Move.cs
@@ -240,8 +240,7 @@ protected override void OnSimulate()
                     {
                         if (hasPath)
                         {
-                            //TODO: fix this shit
-                            repathCount--;
+                            //repathCount--;
                         } else
                         {
                             repathCount--;
@@ -281,7 +280,7 @@ protected override void OnSimulate()
                 if (distance > closingDistance || movingToWaypoint)
                 {
                     desiredVelocity = (movementDirection);
-                    if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y).AbsMoreThan(FixedMath.Half))
+                    if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y) != 0)
                     {
                         lastMovementDirection = movementDirection;
                         cachedTurn.StartTurnRaw(movementDirection);
@@ -308,8 +307,31 @@ protected override void OnSimulate()
                 cachedBody._velocity += (desiredVelocity - cachedBody._velocity) * timescaledAcceleration;
 
                 cachedBody.VelocityChanged = true;
-               
-
+                if (collidedWithTrackedAgent)
+                {
+                    if (collidedCount >= CollisionStopCount)
+                    {
+                        collidedCount = 0;
+                        collidingAgent = null;
+                        Arrive();
+                    } else
+                    {
+                        if (lastPosition.FastDistance(cachedBody._position.x, cachedBody._position.y)
+                        < collisionStopTreshold)
+                        {
+                            collidedCount++;
+                        } else
+                        {
+                            lastPosition = cachedBody._position;
+                            collidedCount = 0;
+                        }
+                    }
+                    collidedWithTrackedAgent = false;
+                } else
+                {
+                    collidingAgent = null;
+                    collidedCount = 0;
+                }
             } else
             {
                 if (cachedBody.VelocityFastMagnitude > 0)
@@ -323,16 +345,15 @@ protected override void OnSimulate()
 
         protected override void OnExecute(Command com)
         {
-            if (com.ContainsData<Vector2d> ())
+            if (com.HasPosition)
             {
                 Agent.StopCast(ID);
                 RegisterGroup();
                 if (straightPath)
                 {
-                    repathCount /= 8;
                 } else
                 {
-                    repathCount /= 8;
+                    repathCount /= 4;
                 }
             }
         }
@@ -431,12 +452,12 @@ protected override void OnStopCast()
 
         private int collidedCount;
         private ushort collidedID;
-
+        private LSAgent collidingAgent;
+        private bool collidedWithTrackedAgent;
         static LSAgent tempAgent;
 
         private void HandleCollision(LSBody other)
         {
-            
             if (!CanMove)
             {
                 return;
@@ -445,12 +466,19 @@ private void HandleCollision(LSBody other)
             {
                 return;
             }
-
+            if (tempAgent == collidingAgent)
+                collidedWithTrackedAgent = true;
+            else if (collidingAgent == null)
+            {
+                collidingAgent = tempAgent;
+                collidedWithTrackedAgent = true;
+            }
             Move otherMover = tempAgent.Mover;
             if (ReferenceEquals(otherMover, null) == false)
             {
                 if (IsMoving && CanCollisionStop)
                 {
+                    Debug.Log(this.MyMovementGroupID + ", " + otherMover.MyMovementGroupID);
                     if (otherMover.MyMovementGroupID == MyMovementGroupID)
                     {
                         if (otherMover.IsMoving == false && otherMover.Arrived && otherMover.stopTime > MinimumOtherStopTime)
diff --git a/Core/Game/Abilities/Essential/Scan.cs b/Core/Game/Abilities/Essential/Scan.cs
index 33217e01..287c35b3 100644
--- a/Core/Game/Abilities/Essential/Scan.cs
+++ b/Core/Game/Abilities/Essential/Scan.cs
@@ -6,7 +6,7 @@ namespace Lockstep
 {
     public class Scan : ActiveAbility
     {
-        private const int SearchRate = (int)(LockstepManager.FrameRate / 2);
+        private const int SearchRate =  (int)(LockstepManager.FrameRate / 2);
         public const long MissModifier = FixedMath.One / 2;
 
         public virtual bool CanMove { get; private set; }
@@ -41,23 +41,17 @@ public bool HasTarget
 
         public virtual string ProjCode { get { return _projectileCode; } }
 
-        public virtual long Range { get { return _range; } }
-        //Range
+        public virtual long Range { get { return _range; } } //Range
 
-        public virtual long Sight { get { return _sight; } }
-        //Approximate radius that's scanned for targets
+        public virtual long Sight { get { return _sight; } } //Approximate radius that's scanned for targets
 
-        public virtual long Damage { get { return _damage; } }
-        //Damage of attack
+        public virtual long Damage { get { return _damage; } } //Damage of attack
 
-        public virtual int AttackRate { get { return _attackRate; } }
-        //Frames between each attack
+        public virtual int AttackRate { get { return _attackRate; } } //Frames between each attack
 
-        public virtual bool TrackAttackAngle { get { return _trackAttackAngle; } }
-        //Whether or not to require the unit to face the target for attacking
+        public virtual bool TrackAttackAngle { get { return _trackAttackAngle; } } //Whether or not to require the unit to face the target for attacking
 
-        public long AttackAngle { get { return _attackAngle; } }
-        //The angle in front of the unit that the target must be located in
+        public long AttackAngle { get { return _attackAngle; } } //The angle in front of the unit that the target must be located in
 
         protected virtual AllegianceType TargetAllegiance //Allegiance to the target
         {
@@ -66,18 +60,15 @@ protected virtual AllegianceType TargetAllegiance //Allegiance to the target
 
         protected virtual PlatformType TargetPlatform //PlatformType of the target
         {
-            get { return this._targetPlatform; }
+            get {return this._targetPlatform;}
         }
 
-        public Vector2d ProjectileOffset { get { return _projectileOffset.ToOrientedVector2d(); } }
-        //Offset of projectile
+        public Vector2d ProjectileOffset { get { return _projectileOffset.ToOrientedVector2d(); } } //Offset of projectile
 
-        public float ProjectileHeightOffset { get { return _projectileOffset.Height; } }
-        //Offset of projectile on the Y axis
+        public float ProjectileHeightOffset { get { return _projectileOffset.Height; } } //Offset of projectile on the Y axis
 
         #region Serialized Values (Further description in properties)
-
-        [SerializeField,DataCode("Projectiles")]
+        [SerializeField,DataCode ("Projectiles")]
         protected string _projectileCode;
         [FixedNumber, SerializeField]
         protected long _range = FixedMath.One * 6;
@@ -112,9 +103,7 @@ protected virtual PlatformType TargetPlatform //PlatformType of the target
         private int attackFrameCount;
         private Move cachedMove;
         private Turn cachedTurn;
-
-        private LSBody cachedBody { get { return Agent.Body; } }
-
+        private LSBody cachedBody {get {return Agent.Body;}}
         private int rangeDeltaCount;
         private int baseDeltaCount;
         private int basePriority;
@@ -141,21 +130,20 @@ protected override void OnSetup()
             attackFrameCount = AttackRate;
             basePriority = cachedBody.Priority;
 
-            CanMove = cachedMove.IsNotNull();
+            CanMove = cachedMove .IsNotNull();
             if (CanMove)
             {
                 cachedMove.OnArrive += HandleOnArrive;
                 cachedMove.onGroupProcessed += _HandleMoveGroupProcessed;
             }
 
-            CanTurn = cachedTurn.IsNotNull();
+            CanTurn = cachedTurn .IsNotNull();
 
         }
 
         private void HandleOnArrive()
         {
-            if (this.isAttackMoving)
-            {
+            if (this.isAttackMoving) {
                 if (this.HasTarget == false)
                     isAttackMoving = false;
             }
@@ -204,15 +192,15 @@ void BehaveWithTarget()
                 if (!inRange)
                 {
                     if (CanMove)
-                        cachedMove.StopMove();
+                    cachedMove.StopMove();
                 }
                 Agent.SetState(AnimState.Engaging);
                 long mag = FixedMath.Sqrt(fastMag >> FixedMath.SHIFT_AMOUNT);
                 //cachedTurn.StartTurn(targetDirection / mag);
                 bool withinTurn = TrackAttackAngle == false ||
-                                  (fastMag != 0 &&
-                                  cachedBody._rotation.Dot(targetDirection.x, targetDirection.y) > 0
-                                  && cachedBody._rotation.Cross(targetDirection.x, targetDirection.y).Abs() <= AttackAngle);
+                    (fastMag != 0 &&
+                     cachedBody.Rotation.Dot(targetDirection.x, targetDirection.y) > 0
+                     && cachedBody.Rotation.Cross(targetDirection.x, targetDirection.y).Abs() <= AttackAngle);
                 bool needTurn = mag != 0 && !withinTurn;
                 if (needTurn)
                 {
@@ -221,7 +209,8 @@ void BehaveWithTarget()
                         targetDirection /= mag;
                         cachedTurn.StartTurn(targetDirection);
                     }
-                } else
+                } 
+                else
                 {
                     if (attackCount <= 0)
                     {
@@ -294,7 +283,7 @@ void BehaveWithNoTarget()
                 }
             }
         }
-
+        
         public void Fire()
         {
             if (Agent.UseEnergy(this.EnergyCost))
@@ -324,14 +313,14 @@ public void Engage(LSAgent other)
             if (other != Agent)
             {
                 cachedTargetHealth = other.Healther;
-                if (cachedTargetHealth.IsNotNull())
+                if (cachedTargetHealth .IsNotNull())
                 {
                     Target = other;
 
                     HasTarget = true;
                     targetVersion = Target.SpawnVersion;
                     IsCasting = true;
-                    fastRangeToTarget = Range + (Target.Body.IsNotNull() ? Target.Body.Radius : 0);
+                    fastRangeToTarget = Range + (Target.Body .IsNotNull() ? Target.Body.Radius : 0);
                     fastRangeToTarget *= fastRangeToTarget;
                 }
             }
@@ -380,34 +369,33 @@ protected override void OnDeactivate()
         protected override void OnExecute(Command com)
         {
             Agent.StopCast(this.ID);
-            Vector2d pos;
-            DefaultData target;
 
-            if (com.TryGetData<Vector2d>(out pos) && CanMove)
+            if (com.HasPosition || com.HasTarget)
             {
-
-                if (HasTarget)
-                {
-                    cachedMove.RegisterGroup(false);
-                } else
+                if (com.HasPosition && CanMove)
                 {
-                    cachedMove.RegisterGroup();
-                }
 
-                isAttackMoving = true;
-                isFocused = false;
+                    if (HasTarget)
+                    {
+                        cachedMove.RegisterGroup(false);
+                    } else
+                    {
+                        cachedMove.RegisterGroup();
+                    }
 
-            } else if (com.TryGetData<DefaultData> (out target) && target.Is(DataType.UShort))
-            {
-                isFocused = true;
-                isAttackMoving = false;
-                LSAgent tempTarget;
-                DefaultData data;
-                ushort targetValue = (ushort)target.Value;
-                AgentController.TryGetAgentInstance(targetValue, out tempTarget);
-                Engage(tempTarget);
-            }
+                    isAttackMoving = true;
+                    isFocused = false;
+
+                } else if (com.HasTarget)
+                {
 
+                    isFocused = true;
+                    isAttackMoving = false;
+                    LSAgent tempTarget;
+                    AgentController.TryGetAgentInstance(com.Target, out tempTarget);
+                    Engage(tempTarget);
+                }
+            }
         
         }
 
@@ -450,24 +438,21 @@ public bool ScanWithinRangeAndEngage()
                 return true;
             }
         }
-        #if UNITY_EDITOR
+#if UNITY_EDITOR
         [SerializeField, Visualize]
         private Vector3 _projectileOrigin;
-
-        protected override void OnAfterSerialize()
+        protected override void OnAfterSerialize  ()
         {
             if (transform.position != Vector3.zero)
             {
-                Debug.LogWarning("Visual editting can only be used when transform is at origin.");
+                Debug.LogWarning ("Visual editting can only be used when transform is at origin.");
                 return;
             }
-            _projectileOffset = new Vector2dHeight(base.transform.InverseTransformPoint(_projectileOrigin));
+            _projectileOffset = new Vector2dHeight(base.transform.InverseTransformPoint (_projectileOrigin));
         }
-
-        void OnDrawGizmos()
-        {
-            Gizmos.DrawWireSphere(Application.isPlaying ? Agent.Body._visualPosition : this.transform.position, this.Range.ToFloat()); 
+        void OnDrawGizmos () {
+            Gizmos.DrawWireSphere (Application.isPlaying ? Agent.Body.visualPosition : this.transform.position,this.Range.ToFloat()); 
         }
-        #endif
+#endif
     }
 }
\ No newline at end of file
diff --git a/Core/Game/Abilities/Essential/SetHeight.cs b/Core/Game/Abilities/Essential/SetHeight.cs
index 8af1bc6e..680c2bb8 100644
--- a/Core/Game/Abilities/Essential/SetHeight.cs
+++ b/Core/Game/Abilities/Essential/SetHeight.cs
@@ -11,7 +11,7 @@ public class SetHeight : Ability {
 	protected override void OnInitialize ()
 	{
 		changed = false;
-		Agent.Body._visualPosition.y = Offset;
+		Agent.Body.visualPosition.y = Offset;
 	}
 	protected override void OnVisualize ()
 	{
@@ -20,7 +20,7 @@ protected override void OnVisualize ()
 		}
 
 		if (changed) {
-			Agent.Body._visualPosition.y = Offset;
+			Agent.Body.visualPosition.y = Offset;
 		}
 	}
 }
diff --git a/Core/Game/Abilities/Essential/Turn.cs b/Core/Game/Abilities/Essential/Turn.cs
index b8cd1281..407509f3 100644
--- a/Core/Game/Abilities/Essential/Turn.cs
+++ b/Core/Game/Abilities/Essential/Turn.cs
@@ -19,16 +19,13 @@ private VectorRotation
 		const int checkCollisionTurnRate = 1;//LockstepManager.FrameRate;
 		private int checkCollisionCount;
 
-        private long collisionTurnThreshold;
-
 		protected override void OnSetup ()
 		{
 			cachedBody = Agent.Body;
 
 			turnSin = _turnRate.Sin;
 			turnCos = _turnRate.Cos;
-            collisionTurnThreshold = cachedBody.Radius / LockstepManager.FrameRate;
-            collisionTurnThreshold *= collisionTurnThreshold;
+
 			cachedBody.OnContact += HandleContact;
 		}
 
@@ -36,18 +33,47 @@ protected override void OnInitialize ()
 		{
 			targetReached = true;
 			targetRotation = Vector2d.up;
-            checkCollisionCount = 0;
-            cachedBeginCheck = 0;
+			contactChecked = false;
+			checkCollisionCount = 0;
+			contactDif = Vector2d.zero;
+			cachedBeginCheck = 0;
+
+			contacted = false;
+			isContactTurning = false;
 
 			bufferStartTurn = false;
 		}
 
 		protected override void OnSimulate ()
 		{
+			if (targetReached) {
+				if (cachedBody.HasParent == false) {
+					if (contactChecked) {
+						contactChecked = false;
+						checkCollisionCount = checkCollisionTurnRate;
+						contactDif /= contactCount;
+						TurnDirection (contactDif);
+						isContactTurning = true;
+						contactDif = Vector2d.zero;
+						contactCount = 0;
+					} else if (checkCollisionCount > 0) {
+						checkCollisionCount--;
+					}
+				}
+			}
 
 
 			if (targetReached == false) {
+				if (isContactTurning) {
+					if (contacted) {
 
+						contacted = false;
+					}
+					else {
+						targetReached = true;
+						isContactTurning = false;
+					}
+				}
 				if (cachedBeginCheck != 0) {
 					{
 						if (cachedBeginCheck < 0) {
@@ -58,20 +84,20 @@ protected override void OnSimulate ()
 					}
 
 				} else {
-					if (cachedBody._rotation.Dot (targetRotation.x, targetRotation.y) < 0) {
+					if (cachedBody.Rotation.Dot (targetRotation.x, targetRotation.y) < 0) {
 						cachedBody.Rotate (turnCos, turnSin);
 					} else {
 						Arrive ();
 					}
 				}
 				cachedBody.RotationChanged = true;
-			}
+			} 
 		}
 
 		protected override void OnLateSimulate ()
 		{
 			if (targetReached == false) {
-				long check = cachedBody._rotation.Cross (targetRotation.x, targetRotation.y);
+				long check = cachedBody.Rotation.Cross (targetRotation.x, targetRotation.y);
 				if (check == 0 || ((cachedBeginCheck < 0) != (check < 0))) {
 					Arrive ();
 				}
@@ -84,8 +110,9 @@ protected override void OnLateSimulate ()
 
 		private void Arrive ()
 		{
-			cachedBody._rotation = targetRotation;
-            cachedBody.RotationChanged = true;
+			cachedBody.Rotation = targetRotation;
+			cachedBody.UpdateLocalRotation ();
+			cachedBody.RotationChanged = true;
 			targetReached = true;
 		}
 
@@ -97,21 +124,22 @@ public void TurnDirection (Vector2d targetDirection)
 
 		public void StartTurn (Vector2d targetRot)
 		{
-            bufferStartTurn = true;
+			bufferStartTurn = true;
 			bufferTargetRot = targetRot;
-        }
+			isContactTurning = false;
+		}
 		public void StartTurnRaw (Vector2d targetRot) {
 			targetRotation = targetRot;
 			targetReached = false;
-			cachedBeginCheck = cachedBody._rotation.Cross (targetRot.x,targetRot.y);
+			cachedBeginCheck = cachedBody.Rotation.Cross (targetRot.x,targetRot.y);
 		}
 		private void _StartTurn (Vector2d targetRot) {
 			long tempCheck;
-			if (targetRot.NotZero () && (tempCheck = cachedBody._rotation.Cross (targetRot.x, targetRot.y)) != 0) {
-				if (tempCheck.AbsMoreThan (turnSin) == false && cachedBody._rotation.Dot (targetRot.x,targetRot.y) > 0)
+			if (targetRot.NotZero () && (tempCheck = cachedBody.Rotation.Cross (targetRot.x, targetRot.y)) != 0) {
+				if (tempCheck.AbsMoreThan (turnSin) == false && cachedBody.Rotation.Dot (targetRot.x,targetRot.y) > 0)
 				{
 					targetRotation = targetRot;
-                    Arrive ();
+					Arrive ();
 				}
 				else {
 					cachedBeginCheck = tempCheck;
@@ -134,16 +162,32 @@ protected override void OnStopCast ()
 		{
 			StopTurn ();
 		}
-            
+
+		private bool isContactTurning;
+		private bool contactChecked;
+		private Vector2d contactDif;
+		private int contactCount;
+		private bool contacted;
 
 		private void HandleContact (LSBody other)
 		{
-            if (targetReached == true && Agent.IsCasting == false) {
-                Vector2d delta = this.cachedBody._position - this.cachedBody.LastPosition;
-                if (delta.FastMagnitude() > collisionTurnThreshold) {
-                    delta.Normalize();
-                    this.StartTurn(delta);
-                }
+			contacted = true;
+			if (cachedBody.HasParent == false) {
+				if (targetReached == true && Agent.IsCasting == false) {
+					if (other.Priority >= cachedBody.Priority) {
+						if (checkCollisionCount == 0) {
+							const long collisionTurnTreshold = FixedMath.One;
+							if (this.cachedBody.VelocityFastMagnitude < other.VelocityFastMagnitude || other.VelocityFastMagnitude == 0) {
+                                contactDif += cachedBody._position - other._position;
+								if (cachedBody.Rotation.Dot (contactDif.x, contactDif.y) >= 0) {
+									contactCount++;
+									contactChecked = true;
+								}
+							}
+						}
+
+					}
+				}
 			}
 		}
 	}
diff --git a/Core/Game/Agents/AgentController.cs b/Core/Game/Agents/AgentController.cs
index 744e9a44..5ffec6e6 100644
--- a/Core/Game/Agents/AgentController.cs
+++ b/Core/Game/Agents/AgentController.cs
@@ -20,7 +20,7 @@ public sealed class AgentController
 
         public static ushort PeakGlobalID { get; private set; }
 
-        public const int MaxAgents = 16384;
+        public const int MaxAgents = 512;
         private static readonly Dictionary<string,AgentInterfacer> CodeInterfacerMap = new Dictionary<string, AgentInterfacer>();
 
         public static void Setup()
@@ -182,7 +182,7 @@ public static int GetStateHash()
                 if (GlobalAgentActive [i])
                 {
                     LSAgent agent = GlobalAgents [i];
-                    int n1 = agent.Body._position.GetStateHash() + agent.Body._rotation.GetStateHash();
+                    int n1 = agent.Body._position.GetStateHash() + agent.Body.Rotation.GetStateHash();
                     switch (operationToggle)
                     {
                         case 0:
@@ -203,7 +203,7 @@ public static int GetStateHash()
                     if (agent.Body.IsNotNull())
                     {
                         hash ^= agent.Body._position.GetStateHash();
-                        hash ^= agent.Body._position.GetStateHash();
+                        hash ^= agent.Body.Rotation.GetStateHash();
                     }
                 }
             }
@@ -233,11 +233,7 @@ public static int GetStateHash()
         private readonly FastList<AllegianceType> DiplomacyFlags = new FastList<AllegianceType>();
         private readonly FastStack<ushort> OpenLocalIDs = new FastStack<ushort>();
 
-        public static AgentController Create () {
-            return new AgentController();
-        }
-
-        private AgentController()
+        internal AgentController()
         {
             if (InstanceManagers.Count > byte.MaxValue) {
                 throw new System.Exception("Cannot have more than 256 AgentControllers");
@@ -268,22 +264,39 @@ public void RemoveFromSelection(LSAgent agent)
             SelectionChanged = true;
         }
 
-        private Selection previousSelection = new Selection();
+        private Selection previousSelection;
 
         public void Execute(Command com)
         {
-           
+            if (com.LeInput == InputCode.Spawn)
             {
-                if (com.ContainsData<Selection>() == false)
-                    com.Add<Selection>( previousSelection);
-                previousSelection = com.GetData<Selection>();
+                for (int i = 0; i < com.Count; i++)
+                {
+                    LSAgent agent = CreateAgent(GetAgentCode(com.Target), com.Position,null);
+                }
+                return;
             }
-
-
+            
+            
+            if (com.HasGroupID)
+            {
+                /*var group = AgentGroupController.GetGroup(com.GroupID);
+                if (group .IsNotNull ()) {
+                    for (i = 0; i < group.Agents.Count; i++) {
+                        group.Agents[i].Execute(com);
+                    }
+                }*/
+            } else
+            {
+                if (com.HasSelect == false)
+                    com.Select = previousSelection;
+                previousSelection = com.Select;
+            }
+            
             BehaviourHelperManager.Execute(com);
-            for (int i = 0; i < com.GetData<Selection>().selectedAgentLocalIDs.Count; i++)
+            for (int i = 0; i < com.Select.selectedAgentLocalIDs.Count; i++)
             {
-                ushort selectedAgentID = com.GetData<Selection>().selectedAgentLocalIDs [i];
+                ushort selectedAgentID = com.Select.selectedAgentLocalIDs [i];
                 if (LocalAgentActive [selectedAgentID])
                 {
                     LocalAgents [selectedAgentID].Execute(com);
@@ -293,17 +306,12 @@ public void Execute(Command com)
 
         public static Command GenerateSpawnCommand(AgentController cont, string agentCode, int count, Vector2d position)
         {
-            //Temporarily disabled
-            //TODO: reimplement with BehaviourHelper system
-            /*
             Command com = new Command(InputCode.Spawn);
             com.ControllerID = cont.ControllerID;
             com.Position = position;
             com.Target = (ushort)AgentController.GetAgentCodeIndex(agentCode);
             com.Count = count;
             return com;
-            */
-            throw new System.NotImplementedException();
         }
 
         public LSAgent CreateAgent(
diff --git a/Core/Game/Agents/LSAgent.cs b/Core/Game/Agents/LSAgent.cs
index d4e51c26..6a3f33d6 100644
--- a/Core/Game/Agents/LSAgent.cs
+++ b/Core/Game/Agents/LSAgent.cs
@@ -21,7 +21,7 @@ namespace Lockstep {
     public class LSAgent : CerealBehaviour, IMousable {
 
         Vector3 IMousable.WorldPosition {
-            get {return this.Body._visualPosition;}
+            get {return this.Body.visualPosition;}
         }
         float IMousable.MousableRadius {
             get {return this.SelectionRadius;}
@@ -51,12 +51,8 @@ public LSBusStop BusStop {
         public event Action<bool, bool> onInteraction;
 		public event Action<LSAgent> onBuildChild;
         public event Action<LSAgent> onInitialized;
-
-        [SerializeField]
-        private int _globalID;
-        public ushort GlobalID { get {return(ushort) _globalID;} private set {_globalID = (int)value;} }
-
-        public ushort LocalID { get; private set;}
+        public ushort GlobalID { get; private set; }
+        public ushort LocalID { get; private set; }
         public uint BoxVersion { get; set; }
 
 		[SerializeField]
@@ -207,14 +203,16 @@ public bool IsInjured {
 
         public AgentInterfacer Interfacer {get; private set;}
         private readonly FastList<int> TrackedLockstepTickets = new FastList<int>();
+
         void Awake () {
             gameObject.SetActive(false);
-
         }
+
         public void Setup(AgentInterfacer interfacer) {
-            gameObject.SetActive(true);
+			
             LoadComponents ();
 
+
 			GameObject.DontDestroyOnLoad(gameObject);
 
 			setupAbilitys.FastClear();
@@ -246,8 +244,6 @@ public void Setup(AgentInterfacer interfacer) {
 			StatsBarer.Setup (this);
 
             this.RegisterLockstep();
-
-
         }
         private void RegisterLockstep () {
             TrackedLockstepTickets.Add (LSVariableManager.Register(this.Body));
@@ -292,9 +288,9 @@ public void Initialize(
 			Selectable = true;
 
 
-            CachedGameObject.SetActiveIfNot (true);
+			CachedGameObject.SetActive (true);
             if (Body .IsNotNull ()) {
-                Body.Initialize(new Vector2dHeight(position), rotation);
+                Body.Initialize(position, rotation);
             }
 
             if (Triggers.IsNotNull()) {
@@ -412,7 +408,7 @@ private IEnumerator<int> PoolDelayer() {
 
         private void Pool() {
             AgentController.CacheAgent(this);
-			if (CachedGameObject != null)
+			if (CachedGameObject .IsNotNull ())
             CachedGameObject.SetActive (false);
         }
 
@@ -436,11 +432,23 @@ public long GetStateHash () {
             hash ^= this.GlobalID;
             hash ^= this.LocalID;
             hash ^= this.Body._position.GetStateHash ();
-            hash ^= this.Body._rotation.GetStateHash ();
+            hash ^= this.Body.Rotation.GetStateHash ();
             hash ^= this.Body.Velocity.GetStateHash ();
             return hash;
         }
-            
+
+		public LSAgent BuildChild (string agentCode, Vector2d localPos, float localHeight) {
+			LSAgent agent = this.Controller.CreateAgent (agentCode);
+			agent.Body.Parent = this.Body;
+			agent.Body.LocalPosition = localPos;
+			agent.Body.LocalRotation = Vector2d.up.rotatedRight;
+			agent.Body.visualPosition.y = localHeight + this.Body.LocalPosition.y;
+			agent.Body.UpdatePosition ();
+			agent.Body.UpdateRotation();
+			agent.Body.BuildChangedValues ();
+			if (onBuildChild .IsNotNull ()) onBuildChild (agent);
+			return agent;
+		}
 
         private void LoadComponents () {
             _cachedTransform = base.transform;
@@ -466,7 +474,6 @@ public override bool GetSerializedFieldNames(List<string> output)
             output.Add("_selectionRadius");
             output.Add("_statsBarOffset");
             output.Add("_visualCenter");
-            output.Add("_globalID");
             return true;
         }
 		/*protected override bool OnSerialize ()
diff --git a/Core/Game/Agents/Teams/Team.cs b/Core/Game/Agents/Teams/Team.cs
index 8f087176..e85e5e8b 100644
--- a/Core/Game/Agents/Teams/Team.cs
+++ b/Core/Game/Agents/Teams/Team.cs
@@ -36,7 +36,7 @@ public void Initialize ()
             TeamManager.Teams.Add(this);
 			this.SetAllegiance (this, AllegianceType.Friendly);
 
-			MainController = AgentController.Create();
+			MainController = new AgentController();
 			MainController.JoinTeam (this);
 
 		}
diff --git a/Core/Game/Agents/Visuals/AbilityInterfacer.cs b/Core/Game/Agents/Visuals/AbilityInterfacer.cs
index 5e51fe19..83197e83 100644
--- a/Core/Game/Agents/Visuals/AbilityInterfacer.cs
+++ b/Core/Game/Agents/Visuals/AbilityInterfacer.cs
@@ -10,7 +10,7 @@ namespace Lockstep.Data {
         false,
         Rotorz.ReorderableList.ReorderableListFlagsUtility.DefinedItems,
         true,
-        typeof (ActiveAbility))]
+        typeof (Ability))]
 #endif
     [Serializable]
 
@@ -23,12 +23,6 @@ public static void Setup ()
             AbilityInterfacer[] interfacers = (LSDatabaseManager.CurrentDatabase as DefaultLSDatabase).AbilityData;
             for (int i = 0; i < interfacers.Length; i++) {
                 AbilityInterfacer interfacer = interfacers[i];
-                if (interfacer.Script.Type == null) {
-                    Debug.Log(interfacer.Name);
-
-                    //exception or ignore?
-                    continue;
-                }
                 CodeInterfacerMap.Add(interfacer.Name, interfacer);
                 TypeInterfacerMap.Add(interfacer.Script.Type, interfacer);
             }
@@ -48,35 +42,23 @@ public static AbilityInterfacer FindInterfacer (Type type) {
                 return interfacer;
             return null;
         }
-        public static AbilityInterfacer FindInterfacer<TAbility> ()  where TAbility : ActiveAbility {
-            return FindInterfacer (typeof (TAbility));
-        }
 
         public string GetAbilityCode () {
             return this.Name;
         }
        
 
-        [SerializeField,DataCode ("Input")]
-        private string _listenInputCode;
-        bool ListenInputInitialized{get; set;}
-        private ushort _listenInputID;
-        public string ListenInputCode {get {return _listenInputCode;}}
-        public ushort ListenInputID {
-            get {
-                if (ListenInputInitialized) {
-                    return _listenInputID;
-                }
-                else {
-                    ListenInputInitialized = true;
-                    return _listenInputID = InputCodeManager.GetCodeID (_listenInputCode);
-                }
-            }
-        }
-        [SerializeField]
+		[SerializeField]
+        private InputCode _listenInput = InputCode.None;
+		public InputCode ListenInput {get {return _listenInput;}}
+		[SerializeField]
 		private InformationGatherType _informationGather;
 		public InformationGatherType InformationGather {get {return _informationGather;}}
+		[SerializeField]
+		private MarkerType _markType;
+		public MarkerType MarkType {get {return _markType;}}
 
-    }
+		public int TileIndex {get {return (int) ListenInput;}}
+	}
 
 }
\ No newline at end of file
diff --git a/Core/Game/Player/RTSInterfacingHelper.cs b/Core/Game/Agents/Visuals/InterfaceManager.cs
similarity index 53%
rename from Core/Game/Player/RTSInterfacingHelper.cs
rename to Core/Game/Agents/Visuals/InterfaceManager.cs
index efcdaa83..7de5a8ab 100644
--- a/Core/Game/Player/RTSInterfacingHelper.cs
+++ b/Core/Game/Agents/Visuals/InterfaceManager.cs
@@ -5,9 +5,22 @@
 
 namespace Lockstep
 {
-    public class RTSInterfacingHelper : InterfacingHelper
+    public static class InterfaceManager
     {
         public static GUIManager GUIManager;
+        private static BuildNode _currentBuildTile;
+
+        public static BuildNode CurrentBuildTile
+        {
+            get
+            {
+                return _currentBuildTile;
+            }
+            set
+            {
+                _currentBuildTile = value;
+            }
+        }
 
         private static AbilityInterfacer _currentInterfacer;
 
@@ -29,54 +42,61 @@ public static AbilityInterfacer CurrentInterfacer
 
         public static bool IsGathering { get; private set; }
 
-        static void Setup()
+        public static void Setup()
         {
             QuickPos = AbilityInterfacer.FindInterfacer ("Move");
             QuickTarget = AbilityInterfacer.FindInterfacer("Scan");
-
-            Setted = true;
         }
-        static bool Setted = false;
 
-        protected override void OnInitialize()
+        public static void Initialize()
         {
-            if (!Setted)
-                Setup ();
-            SelectionManager.Initialize();
-
-            RTSInterfacing.Initialize();
+            Interfacing.Initialize();
             IsGathering = false;
             CurrentInterfacer = null;
         }
 
         static Command curCom;
-        protected override void OnVisualize()
-        {
-            SelectionManager.Update();
 
+        public static void Visualize()
+        {
+            if (CommandManager.sendType == SendState.None)
+                return;
+            Interfacing.Visualize();
+            if (CurrentBuildTile .IsNotNull())
+            {
+                if (InputManager.GetInformationDown())
+                {
+                    if (GUIManager.CanInteract)
+                    {
+                        
+                        GUIManager.InformationDown ();
+                        CurrentBuildTile = null;
+                    }
+                }
+            }
 
-            RTSInterfacing.Visualize();
+            BuildManager.Visualize ();
 
             if (IsGathering)
             {
-                if (Input.GetMouseButtonDown(1))
+                if (InputManager.GetQuickDown())
                 {
                     IsGathering = false;
                     return;
                 }
 
-                if (Input.GetMouseButtonDown(0) || CurrentInterfacer.InformationGather == InformationGatherType.None)
+                if (InputManager.GetInformationDown() || CurrentInterfacer.InformationGather == InformationGatherType.None)
                 {
                     ProcessInterfacer(CurrentInterfacer);
                 }
             } else
             {
                 if (Selector.MainSelectedAgent != null) {
-                    if (Input.GetMouseButtonDown(1))
+                if (InputManager.GetQuickDown())
                 {
                     LSAgent target;
-                    if (RTSInterfacing.MousedAgent.IsNotNull() &&
-                        PlayerManager.GetAllegiance(RTSInterfacing.MousedAgent) == AllegianceType.Enemy && 
+                    if (Interfacing.MousedAgent.IsNotNull() &&
+                        PlayerManager.GetAllegiance(Interfacing.MousedAgent) == AllegianceType.Enemy && 
                         Selector.MainSelectedAgent.Scanner != null)
                     {
                         ProcessInterfacer((QuickTarget));
@@ -94,40 +114,36 @@ private static void ProcessInterfacer(AbilityInterfacer facer)
             switch (facer.InformationGather)
             {
                 case InformationGatherType.Position:
-                    curCom = new Command(facer.ListenInputID);
-                    curCom.Add<Vector2d> ( RTSInterfacing.GetWorldPosD(Input.mousePosition));
+                    curCom = new Command(facer.ListenInput);
+                    curCom.Position = Interfacing.GetWorldPosD(Input.mousePosition);
                     break;
                 case InformationGatherType.Target:
-                    curCom = new Command(facer.ListenInputID);
-                    if (RTSInterfacing.MousedAgent .IsNotNull())
+                    curCom = new Command(facer.ListenInput);
+                    if (Interfacing.MousedAgent .IsNotNull())
                     {
-                        curCom.SetData<DefaultData> (new DefaultData(DataType.UShort,RTSInterfacing.MousedAgent.LocalID));
+                        curCom.Target = Interfacing.MousedAgent.LocalID;
                     }
                     break;
                 case InformationGatherType.PositionOrTarget:
-                    curCom = new Command(facer.ListenInputID);
-                    if (RTSInterfacing.MousedAgent .IsNotNull())
+                    curCom = new Command(facer.ListenInput);
+                    if (Interfacing.MousedAgent .IsNotNull())
                     {
-                        curCom.Add<DefaultData> (new DefaultData(DataType.UShort,RTSInterfacing.MousedAgent.GlobalID));
+                        curCom.Target = Interfacing.MousedAgent.GlobalID;
                     } else
                     {
-                        curCom.Add<Vector2d> (RTSInterfacing.GetWorldPosD(Input.mousePosition));
+                        curCom.Position = Interfacing.GetWorldPosD(Input.mousePosition);
                     }
                     break;
                 case InformationGatherType.None:
-                    curCom = new Command(facer.ListenInputID);
+                    curCom = new Command(facer.ListenInput);
                     break;
             }
-
+            if (facer.MarkType != MarkerType.None)
+            {
+                Interfacing.ActivateMarkerOnMouse(facer.MarkType);
+            }
             Send(curCom);
         }
-
-        public void DrawGUI () {
-
-        }
-        protected virtual void OnDrawGUI () {
-            SelectionManager.DrawBox(GUIStyle.none);
-        }
         
         private static void Send(Command com)
         {
diff --git a/Core/Game/Player/RTSInterfacingHelper.cs.meta b/Core/Game/Agents/Visuals/InterfaceManager.cs.meta
similarity index 100%
rename from Core/Game/Player/RTSInterfacingHelper.cs.meta
rename to Core/Game/Agents/Visuals/InterfaceManager.cs.meta
diff --git a/Core/Game/Determinism/LSVariable.cs b/Core/Game/Determinism/LSVariable.cs
index c4e275ff..587c755e 100644
--- a/Core/Game/Determinism/LSVariable.cs
+++ b/Core/Game/Determinism/LSVariable.cs
@@ -2,77 +2,54 @@
 using System.Collections;
 using System.Reflection;
 using System;
-using System.Linq;
+
 namespace Lockstep
 {
     //Note: Ideally used for value types (i.e. Struct)
     public sealed class LSVariable
     {
-
-        public LSVariable (object lockstepObject, PropertyInfo info) {
-            
-            Init (lockstepObject, info, info.GetCustomAttributes(typeof (LockstepAttribute), true).FirstOrDefault() as LockstepAttribute);
-        }
-
-        public LSVariable (object lockstepObject, PropertyInfo info, LockstepAttribute attribute) {
-            Init (lockstepObject, info, attribute);
-        }
-
         //Must be PropertyInfo for PropertyInfo .Get[Get/Set]Method ()
-        private void Init (object lockstepObject, PropertyInfo info, LockstepAttribute attribute)
+        public LSVariable(PropertyInfo info)
         {
+            
             this.Info = info;
-            this.LockstepObject = lockstepObject;
-
             //For the Value property... easier accessbility
-            //_getValue = (Func<object>)Delegate.CreateDelegate(typeof(Func<object>), info.GetGetMethod().);
+            _getValue = (Func<object>)Delegate.CreateDelegate(typeof (Func<object>),info.GetGetMethod());
 
-            if (DoReset = attribute.DoReset)
-            {
-               // _setValue = (Action<object>)Delegate.CreateDelegate(typeof(Action<object>), info.GetSetMethod());
-                //Sets the base value for resetting
-                this._baseValue = this.Value;
-            }
+
+            _setValue = (Action<object>)Delegate.CreateDelegate(typeof (Action<object>),info.GetSetMethod());
+            //Sets the base value for resetting
+            this._baseValue = this.Value;
         }
-        public bool DoReset {get; private set;}
 
-        public PropertyInfo Info { get; private set; }
-        public object LockstepObject {get; private set;}
+        public PropertyInfo Info {get; private set;}
 
         private object _baseValue;
-
-        object BaseValue { get { return _baseValue; } }
+        object BaseValue {get {return _baseValue;}}
 
         Func<object> _getValue;
         Action<object> _setValue;
-
         /// <summary>
         /// Gets or sets the value of the target variable.
         /// </summary>
         /// <value>The value.</value>
-        public object Value
-        {
-            get
-            {
-                return Info.GetValue (LockstepObject, null);
+        public object Value {
+            get {
+                return _getValue();
             }
-            private set
-            {
-                Info.SetValue (LockstepObject, value, null);
+            private set {
+                _setValue(value);
             }
         }
 
-        public int Hash()
-        {
+        public int Hash () {
             return Value.GetHashCode();
         }
 
         /// <summary>
         /// Resets the Value to its value at the creation of this LSVariable.
         /// </summary>
-        public void Reset()
-        {
-            if (DoReset)
+        public void Reset () {
             this.Value = this.BaseValue;
         }
     }
diff --git a/Core/Game/Determinism/LSVariableManager.cs b/Core/Game/Determinism/LSVariableManager.cs
index 3626c647..8670b7f2 100644
--- a/Core/Game/Determinism/LSVariableManager.cs
+++ b/Core/Game/Determinism/LSVariableManager.cs
@@ -3,7 +3,6 @@
 using System;
 using System.Reflection;
 using System.Collections.Generic;
-using System.Linq;
 namespace Lockstep
 {
     public static class LSVariableManager
@@ -23,25 +22,25 @@ public static int Register (object lockstepObject) {
             LSVariableContainer container;
             if (!CachedLockstepPropertyNames.TryGetValue(type, out propertyNames)) {
                 bufferPropertyNames.FastClear();
-                container = new LSVariableContainer(GetVariables (lockstepObject, type));
+                container = new LSVariableContainer(GetVariables (type));
                 foreach (LSVariable info in container.Variables) {
                     bufferPropertyNames.Add(info.Info.Name);
                 }
                 CachedLockstepPropertyNames.Add (type, bufferPropertyNames.ToArray());
             }
             else {
-                container = new LSVariableContainer(GetVariables (lockstepObject, type, propertyNames));
+                container = new LSVariableContainer(GetVariables (type, propertyNames));
             }
             return Containers.Add(container);
         }
-        private static IEnumerable <LSVariable> GetVariables (object lockstepObject, Type type, string[] propertyNames) {
+        private static IEnumerable <LSVariable> GetVariables (Type type, string[] propertyNames) {
             //Getting target variables with cache
             foreach (string name in propertyNames) {
-                yield return new LSVariable(lockstepObject, type.GetProperty(name,(BindingFlags)~0));
+                yield return new LSVariable(type.GetProperty(name));
             }
         }
 
-        private static IEnumerable<LSVariable> GetVariables (object lockstepObject, Type type) {
+        private static IEnumerable<LSVariable> GetVariables (Type type) {
             foreach (PropertyInfo info in type.GetProperties((BindingFlags)~0)) {
                 //Make sure the type is something we can work with
 
@@ -57,7 +56,7 @@ private static IEnumerable<LSVariable> GetVariables (object lockstepObject, Type
                         continue;
                     }
 
-                    yield return new LSVariable(lockstepObject, info, attributes.FirstOrDefault() as LockstepAttribute);
+                    yield return new LSVariable(info);
                 }
             }
         }
diff --git a/Core/Game/Determinism/LockstepAttribute.cs b/Core/Game/Determinism/LockstepAttribute.cs
index baea90a2..0dbe5c3c 100644
--- a/Core/Game/Determinism/LockstepAttribute.cs
+++ b/Core/Game/Determinism/LockstepAttribute.cs
@@ -3,12 +3,6 @@
 using System;
 [AttributeUsage (AttributeTargets.Property)]
 public sealed class LockstepAttribute : Attribute {
-    public bool DoReset {get; private set;}
     public LockstepAttribute () {
-        this.DoReset = false;
-    }
-
-    public LockstepAttribute (bool doReset) {
-        DoReset = doReset;
     }
 }
diff --git a/Core/Game/Grouping/MovementGroup.cs b/Core/Game/Grouping/MovementGroup.cs
index c4c76a54..e236ccb4 100644
--- a/Core/Game/Grouping/MovementGroup.cs
+++ b/Core/Game/Grouping/MovementGroup.cs
@@ -19,9 +19,9 @@ public class MovementGroup
 
     public void Initialize(Command com)
     {
-        Destination = com.GetData<Vector2d> ();;
+        Destination = com.Position;
         calculatedBehaviors = false;
-        movers = new FastList<Move>(com.GetData<Selection>().selectedAgentLocalIDs.Count);
+        movers = new FastList<Move>(com.Select.selectedAgentLocalIDs.Count);
     }
 
     public void Add(Move mover)
diff --git a/Core/Game/Grouping/MovementGroupHelper.cs b/Core/Game/Grouping/MovementGroupHelper.cs
index 83561ff8..136b7e04 100644
--- a/Core/Game/Grouping/MovementGroupHelper.cs
+++ b/Core/Game/Grouping/MovementGroupHelper.cs
@@ -5,11 +5,11 @@ namespace Lockstep
 {
     public class MovementGroupHelper : BehaviourHelper
     {
-        public override ushort ListenInput
+        public override InputCode ListenInput
         {
             get
             {
-                return AbilityInterfacer.FindInterfacer(typeof (Move)).ListenInputID;
+                return AbilityInterfacer.FindInterfacer(typeof (Move)).ListenInput;
             }
         }
 
@@ -68,7 +68,7 @@ protected override void OnExecute(Command com)
 
         public static void Execute(Command com)
         {
-            if (com.ContainsData<Vector2d> ())
+            if (com.HasPosition)
             {
                 CreateGroup(com);
             }
diff --git a/Core/Game/Grouping/ScanGroupHelper.cs b/Core/Game/Grouping/ScanGroupHelper.cs
index 7cccd086..7823a248 100644
--- a/Core/Game/Grouping/ScanGroupHelper.cs
+++ b/Core/Game/Grouping/ScanGroupHelper.cs
@@ -5,9 +5,9 @@ namespace Lockstep
 {
 	public class ScanGroupHelper : BehaviourHelper
 	{
-		public override ushort ListenInput {
+		public override InputCode ListenInput {
 			get {
-                return AbilityInterfacer.FindInterfacer(typeof (Scan)).ListenInputID;
+                return AbilityInterfacer.FindInterfacer(typeof (Scan)).ListenInput;
 			}
 		}
 
diff --git a/Core/Game/Managers/ClientManager.cs b/Core/Game/Managers/ClientManager.cs
index 855cff1a..3814b76c 100644
--- a/Core/Game/Managers/ClientManager.cs
+++ b/Core/Game/Managers/ClientManager.cs
@@ -1,10 +1,10 @@
 using UnityEngine;
 using System.Collections;
 using System;
-using Lockstep.NetworkHelpers;
+
 namespace Lockstep
 {
-	public class ClientManager
+	public class ClientManager : MonoBehaviour
 	{
         public static NetworkHelper NetworkHelper;
 		const bool SimulateNetworking = false;
@@ -17,7 +17,7 @@ public class ClientManager
 
 		public static bool GameStarted { get; private set; }
 
-		public static int ClientID {
+		public static ushort ID {
 			get {
 				return NetworkHelper.ID;
 			}
@@ -63,7 +63,7 @@ public static void Initialize ()
 		}
         public static bool Registered {get; private set;}
         private static void Register () {
-            SendMessageToServer (MessageType.Register,new byte[1]);
+            SendMessageToServer (MessageType.Register,LSUtility.EmptyBytes);
         }
 		public static void HandleFrameData (byte[] data) {
 			if (GameStarted) {
@@ -84,6 +84,7 @@ public static void Simulate ()
                 }
                 return;
             }
+			if (CommandManager.sendType == SendState.Network) {
 				if (SimulateNetworking) {
 
 				} else {
@@ -96,7 +97,7 @@ public static void Simulate ()
 						}
 					}
 				}
-			
+			}
 		}
 
 		private static FastQueue<byte[]> bufferedSendData = new FastQueue<byte[]> ();
@@ -128,8 +129,31 @@ public static void Quit ()
 				NetworkHelper.Disconnect ();
 			}
 		}
-            
-		
+
+
+		void OnGUI ()
+		{
+			if (SimulateNetworking == false && CommandManager.sendType == SendState.Network) {
+				if (isConnected == false) {
+					GUILayout.Label ("Host Address: ");
+
+					IP = GUILayout.TextField (IP.ToString ());
+
+					if (GUILayout.Button ("Connect", GUILayout.Width (200f))) {
+						Connect (IP);
+					}
+
+					GUILayout.Space (10f);
+					GUILayout.Label ("Room Size: ");
+					int.TryParse (GUILayout.TextField (RoomSize.ToString ()), out _roomSize);
+					if (GUILayout.Button ("Host", GUILayout.Width (200f))) {
+						NetworkHelper.Host (RoomSize);
+					}
+				} else {
+
+				}
+			}
+		}
 
 		private static void SendMessageToServer (MessageType messageType, byte[] data)
 		{
diff --git a/Core/Game/Managers/CommandManager.cs b/Core/Game/Managers/CommandManager.cs
new file mode 100644
index 00000000..e1427bfa
--- /dev/null
+++ b/Core/Game/Managers/CommandManager.cs
@@ -0,0 +1,131 @@
+using System;
+using UnityEngine;
+
+namespace Lockstep
+{
+	public static class CommandManager
+	{
+		const int defaultSize = 1 << 15;
+		public const SendState defaultSendState = SendState.Network;
+		public static SendState sendType = defaultSendState;
+
+		public static int LastCommandedFrameCount {get; private set;}
+
+        #region Recording
+		public static FastList<byte> RecordedBytes = new FastList<byte> (defaultSize);
+        #endregion
+
+		static int NextFrameCount;
+		static readonly FastList<Command> outCommands = new FastList<Command> (defaultSize);
+		static readonly FastList<byte> bufferedBytes = new FastList<byte> (256);
+		const bool SendAggregated = false;
+
+		public static void Initialize ()
+		{
+			RecordedBytes.FastClear ();
+			outCommands.FastClear ();
+			NextFrameCount = 0;
+			LastCommandedFrameCount = -1;
+		}
+
+		public static void Simulate ()
+		{
+			if (sendType == SendState.None) {
+				return;
+			}
+
+			{
+				bufferedBytes.FastClear ();
+
+				switch (sendType) {
+				case SendState.Network:
+					if (SendAggregated) {
+						for (int i = 0; i < outCommands.Count; i++) {
+							bufferedBytes.AddRange (outCommands [i].Serialized);
+						}
+						if (bufferedBytes.Count > 0)
+							ClientManager.Distribute (bufferedBytes.ToArray ());
+					}
+					break;
+				case SendState.Offline:
+					bufferedBytes.AddRange (BitConverter.GetBytes (LockstepManager.InfluenceFrameCount));
+					for (int i = 0; i < outCommands.Count; i++) {
+						bufferedBytes.AddRange (outCommands [i].Serialized);
+					}
+					ProcessPacket (bufferedBytes.ToArray ());
+					break;
+				}
+				outCommands.FastClear ();
+				NextFrameCount++;
+                
+			}
+		}
+
+		public static void ProcessPacket (byte[] packet)
+		{
+			processBytes.FastClear ();
+			processBytes.AddRange (packet);
+			ProcessPacket (processBytes);
+		}
+
+		static FastList<byte> processBytes = new FastList<byte> ();
+
+		public static void ProcessPacket (FastList<byte> packet)
+		{
+
+			if (packet == null || packet.Count < 4) {
+                throw new System.Exception("Packet is null or not valid length");
+			}
+			int frameCount = BitConverter.ToInt32 (packet.innerArray, 0);
+			int index = 4;
+
+			if (FrameManager.HasFrame (frameCount) == false) {
+				Frame frame = new Frame ();
+
+				if (packet.Count > 4) {
+					RecordedBytes.AddRange (BitConverter.GetBytes ((ushort)packet.Count));
+					RecordedBytes.AddRange (packet);
+					while (index < packet.Count) {
+						Command com = new Command ();
+						index += com.Reconstruct (packet.innerArray, index);
+						frame.AddCommand (com);
+					}
+					if (frameCount > LastCommandedFrameCount) {
+						LastCommandedFrameCount = frameCount;
+                    }
+                }
+				FrameManager.AddFrame (frameCount, frame);
+
+			} else {
+
+			}
+		}
+
+		public static void SendCommand (Command com)
+		{
+			if (sendType == SendState.None) {
+				return;
+			}
+			outCommands.Add (com);
+
+			if (SendAggregated == false) {
+				bufferedBytes.FastClear ();
+				if (sendType == SendState.Network) {
+					for (int i = 0; i < outCommands.Count; i++) {
+						bufferedBytes.AddRange (outCommands [i].Serialized);
+					}
+					outCommands.FastClear ();
+					if (bufferedBytes.Count > 0)
+						ClientManager.Distribute (bufferedBytes.ToArray ());
+				}
+			}
+		}
+	}
+    
+	public enum SendState
+	{
+		None, //Sends no commands and processes no bytes
+		Offline, //Automatically sends commands offline
+		Network //Sends and receives commands from the network
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/CommandManager.cs.meta b/Core/Game/Managers/CommandManager.cs.meta
similarity index 100%
rename from Core/Game/Player/Commands/CommandManager.cs.meta
rename to Core/Game/Managers/CommandManager.cs.meta
diff --git a/Core/Game/Managers/FrameManager.cs b/Core/Game/Managers/FrameManager.cs
index f686a1d6..278ad80f 100644
--- a/Core/Game/Managers/FrameManager.cs
+++ b/Core/Game/Managers/FrameManager.cs
@@ -8,7 +8,6 @@ public static class FrameManager
         private const int StartCapacity = 30000;
         private static bool[] hasFrame = new bool[StartCapacity];
         private static Frame[] frames = new Frame[StartCapacity];
-        public static Frame[] Frames {get {return frames;}}
         private static int capacity = StartCapacity;
         private static int _foreSight;
 
@@ -23,26 +22,19 @@ public static int ForeSight
 
             }
         }
-        private static bool _adjustFramerate;
-        public static bool AdjustFramerate {
-            get {
-                return _adjustFramerate;
-            }
-            set {
-                _adjustFramerate = value;
-            }
-        }
+
         public static void TweakFramerate()
         {
-            if (AdjustFramerate)
+            if (CommandManager.sendType == SendState.Network && ClientManager.NetworkHelper.IsServer == false)
             {
                 float scaler = (float)(ForeSight);
-                scaler -= 0;
-                scaler /= 16;
-                Time.timeScale = 1 + scaler;
+                scaler -= 2;
+                scaler /= 32;
+                Time.timeScale = Mathf.Lerp(Time.timeScale, 1f + (scaler), .5f);
+                Debug.Log(scaler);
             } else
             {
-                Time.timeScale = 1f;
+                //Time.timeScale = 1f;
             }
         }
 
@@ -54,7 +46,7 @@ public static void TweakFramerate()
 
         public static bool CanAdvanceFrame
         {
-            get { return (FreeSimulate || ForeSight > 0 && (ClientManager.GameStarted));}
+            get { return (FreeSimulate || ForeSight > 0 && (CommandManager.sendType != SendState.Network || ClientManager.GameStarted));}
         }
 
         public static bool HasFrame(int frame)
diff --git a/Core/Game/Managers/GameManager/GameManager.cs b/Core/Game/Managers/GameManager/GameManager.cs
index a77ee788..0d3ffe77 100644
--- a/Core/Game/Managers/GameManager/GameManager.cs
+++ b/Core/Game/Managers/GameManager/GameManager.cs
@@ -4,33 +4,16 @@
 using System.Collections;
 using TypeReferences;
 using System;
-using Lockstep.NetworkHelpers;
-
-namespace Lockstep
-{
-    public abstract class GameManager : MonoBehaviour
-    {
+namespace Lockstep {
+    public abstract class GameManager : MonoBehaviour{
 
         [SerializeField]
         BehaviourHelper[] _helpers;
-
-        BehaviourHelper[] Helpers { get { return _helpers; } }
+        BehaviourHelper[] Helpers {get {return _helpers;}}
 
 
         public static GameManager Instance { get; private set; }
 
-        /// <summary>
-        /// If true, LS will run in headless mode and only frames will be processed. Disables all physics, abilities, etc..
-        /// </summary>
-        /// <value><c>true</c> if headless; otherwise, <c>false</c>.</value>
-        public virtual bool Headless
-        {
-            get
-            {
-                return false;
-            }
-        }
-
 
         string replayLoadScene;
         static int hashFrame;
@@ -38,72 +21,44 @@ public virtual bool Headless
         static long stateHash;
         static bool hashChecked;
 
-        private NetworkHelper _mainNetworkHelper;
-
-        public virtual NetworkHelper MainNetworkHelper
-        {
-            get
-            {
-                if (_mainNetworkHelper == null)
-                {
-                    _mainNetworkHelper = GetComponent<NetworkHelper>();
-                    if (_mainNetworkHelper == null)
-                    {
-                        Debug.Log("NetworkHelper not found on this GameManager's GameObject. Defaulting to ExampleNetworkHelper...");
-                        _mainNetworkHelper = new ExampleNetworkHelper();
-                    }
-                }
-                return _mainNetworkHelper;
-            }
-        }
-
-
-        private static RTSInterfacingHelper _defaultHelper = new RTSInterfacingHelper();
-
-        public virtual InterfacingHelper MainInterfacingHelper
-        {
-            get
-            {
-                return _defaultHelper;
-            }
+        public abstract NetworkHelper MainNetworkHelper {
+            get;
         }
 
-        public void ScanForHelpers()
-        {
+        public void ScanForHelpers () {
             //Currently deterministic but not guaranteed by Unity
-            _helpers = this.gameObject.GetComponents<BehaviourHelper>();
+            _helpers = this.gameObject.GetComponents<BehaviourHelper> ();
         }
 
-        public virtual void GetBehaviourHelpers(FastList<BehaviourHelper> output)
-        {
+        public virtual void GetBehaviourHelpers (FastList<BehaviourHelper> output) {
             //if (Helpers == null)
-            ScanForHelpers();
-            if (Helpers != null)
-            {
-                for (int i = 0; i < Helpers.Length; i++)
-                {
-                    output.Add(Helpers [i]);
+                ScanForHelpers ();
+            if (Helpers != null) {
+                for (int i = 0; i < Helpers.Length; i++) {
+                    output.Add(Helpers[i]);
                 }
             }
         }
-
-        protected void Start()
-        {
+    
+        protected void Start () {
             Instance = this;
-            LockstepManager.Initialize(this);
+            LockstepManager.Initialize (this);
             this.Startup();
         }
 
-        protected virtual void Startup()
-        {
+        protected virtual void Startup () {
 
         }
+    
+        public void GameStart () {
+            this.OnGameStart();
+        }
+        protected virtual void OnGameStart () {
+            //When the game starts (first simulation frame)
+        }
 
-
-        protected void FixedUpdate()
-        {
-            LockstepManager.Simulate();
-            /*
+        protected void FixedUpdate () {
+            LockstepManager.Simulate ();
             if (ReplayManager.IsPlayingBack) {
                 if (hashChecked == false) {
                     if (LockstepManager.FrameCount == hashFrame) {
@@ -116,59 +71,66 @@ protected void FixedUpdate()
                         }
                     }
                 }
-            } else 
-
-            {
+            } else {
                 hashFrame = LockstepManager.FrameCount - 1;
                 prevHash = stateHash;
                 stateHash = AgentController.GetStateHash ();
                 hashChecked = false;
             }
-        */
         }
-
+    
         private float timeToNextSimulate;
 
-        protected void Update()
-        {
+        protected void Update () {
             timeToNextSimulate -= Time.smoothDeltaTime * Time.timeScale;
-            if (timeToNextSimulate <= float.Epsilon)
-            {
+            if (timeToNextSimulate <= float.Epsilon) {
                 timeToNextSimulate = LockstepManager.BaseDeltaTime;
             }
-            LockstepManager.Visualize();
-            CheckInput();
+            LockstepManager.Visualize ();
+            CheckInput ();
         }
-
-        protected virtual void CheckInput()
-        {
+    
+        protected virtual void CheckInput () {
         
         }
 
-        void LateUpdate()
-        {
-            LockstepManager.LateVisualize();
+        void LateUpdate () {
+            LockstepManager.LateVisualize ();
         }
 
-        public static void GameStart()
-        {
-            Instance.OnGameStart();
+        public static void StartGame () {
+            Instance.OnStartGame ();
         }
 
-        protected virtual void OnGameStart()
-        {
-            //When the game starts (first simulation frame)
+        protected virtual void OnStartGame () {
+        
         }
-
-        void OnDisable()
-        {
-            LockstepManager.Deactivate();
+    
+        void OnDisable () {
+            //LockstepManager.Deactivate ();
         }
 
-        void OnApplicationQuit()
-        {
-            LockstepManager.Quit();
+        void OnApplicationQuit () {
+            LockstepManager.Quit ();
+        }
+    
+        void OnGUI () {
+        
+            if (CommandManager.sendType == SendState.Network) {
+                return;
+            }
+            if (ReplayManager.IsPlayingBack) {
+                if (GUILayout.Button ("Play")) {
+                    ReplayManager.Stop ();
+                    Application.LoadLevel (Application.loadedLevel);
+                }
+            } else {
+                if (GUILayout.Button ("Replay")) {
+                    ReplayManager.Save ();
+                    ReplayManager.Play ();
+                    Application.LoadLevel (Application.loadedLevel);
+                }
+            }
         }
-
     }
 }
\ No newline at end of file
diff --git a/Core/Game/Managers/Input/InputCode.cs b/Core/Game/Managers/Input/InputCode.cs
new file mode 100644
index 00000000..724ee261
--- /dev/null
+++ b/Core/Game/Managers/Input/InputCode.cs
@@ -0,0 +1,30 @@
+using UnityEngine;
+using System.Collections;
+
+public enum InputCode : byte
+{
+	//S for Special
+	S1,
+	S2,
+	S3,
+	S4,
+
+	//C for Core
+	C1, //Attack
+	C2, //Stop
+	C3, //Move
+	C4,
+
+	//M for Miscellaneous
+	M1,
+	M2,
+	M3,
+	M4,
+
+	Build,
+	Spawn,
+	Meta,
+	None,
+
+    Test,
+}
\ No newline at end of file
diff --git a/Core/Game/Managers/Input/InputCode.cs.meta b/Core/Game/Managers/Input/InputCode.cs.meta
new file mode 100644
index 00000000..ff3a90ae
--- /dev/null
+++ b/Core/Game/Managers/Input/InputCode.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0a672a3e065af4de587c12466651c87a
+timeCreated: 1437169279
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Managers/Input/InputCodeManager.cs b/Core/Game/Managers/Input/InputCodeManager.cs
deleted file mode 100644
index 5dfc3838..00000000
--- a/Core/Game/Managers/Input/InputCodeManager.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using Lockstep.Data;
-namespace Lockstep
-{
-    public static class InputCodeManager
-    {
-        private static BiDictionary<string,ushort> InputMap = new BiDictionary<string, ushort>();
-        private static bool Setted {get; set;}
-        public static void Setup () {
-            InputDataItem[] inputData = (LSDatabaseManager.CurrentDatabase as DefaultLSDatabase).InputData;
-            for (int i = inputData.Length - 1; i >= 0; i--) {
-                ushort id = (ushort)(i + 1);
-                string code = inputData[i].Name;
-                InputMap.Add(code,id);
-            }
-            Setted = true;
-        }
-        public static ushort GetCodeID (string code) {
-            if (!Setted)
-                throw NotSetupException;
-
-            if (string.IsNullOrEmpty(code))
-                return 0;
-            try {
-                
-                return InputMap[code];
-            }
-            catch {
-
-                throw new System.Exception(string.Format("Code '{0}' does not exist in the current database", code));
-            }
-        }
-        public static string GetIDCode (ushort id) {
-            if (!Setted)
-                throw NotSetupException;
-            if (id == 0)
-                return "";
-            return InputMap.GetReversed(id);
-        }
-        static System.Exception NotSetupException {
-            get {
-                return new System.Exception("InputCodeManager has not yet been setup.");
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Managers/Input/InputManager.cs b/Core/Game/Managers/Input/InputManager.cs
new file mode 100644
index 00000000..e4082496
--- /dev/null
+++ b/Core/Game/Managers/Input/InputManager.cs
@@ -0,0 +1,55 @@
+using UnityEngine;
+using System.Collections;
+using System;
+using Lockstep.UI;
+public class InputManager : MonoBehaviour {
+	public static readonly InputCode[] InputCodes = (InputCode[])Enum.GetValues(typeof(InputCode));
+	private static readonly UnityEngine.KeyCode[] mappedKeyCodes = new KeyCode[InputCodes.Length];
+	private static readonly uint[] cachedPressedDown = new uint[InputCodes.Length];
+	private static uint _Version;
+	public static void Setup () {
+		mappedKeyCodes[0] = KeyCode.Q;
+		mappedKeyCodes[1] = KeyCode.W;
+		mappedKeyCodes[2] = KeyCode.E;
+		mappedKeyCodes[3] = KeyCode.R;
+		mappedKeyCodes[4] = KeyCode.A;
+		mappedKeyCodes[5] = KeyCode.S;
+		mappedKeyCodes[6] = KeyCode.D;
+		mappedKeyCodes[7] = KeyCode.F;
+		mappedKeyCodes[8] = KeyCode.Z;
+		mappedKeyCodes[9] = KeyCode.X;
+		mappedKeyCodes[10] = KeyCode.C;
+		mappedKeyCodes[11] = KeyCode.V;
+	}
+	public static bool GetInputDown (InputCode inputCode) {
+		byte inputIndex = (byte)inputCode;
+		if (cachedPressedDown[inputIndex] == _Version)
+		{
+			return true;
+		}
+		bool pressedDown = Input.GetKeyDown (mappedKeyCodes[inputIndex]);
+		if (pressedDown)
+		{
+			cachedPressedDown[inputIndex] = _Version;
+			return true;
+		}
+		return false;
+	}
+	public static void PressInputDown (InputCode inputCode) {
+		byte inputIndex = (byte)inputCode;
+		cachedPressedDown[inputIndex] = _Version;
+	}
+
+	const int InformationMouse = 0;
+	const int QuickMouse = 1;
+	public static bool GetInformationDown () {
+		return Input.GetMouseButtonDown (InformationMouse);
+	}
+	public static bool GetQuickDown () {
+		return Input.GetMouseButtonDown (QuickMouse);
+	}
+	public static void Visualize ()
+	{
+		_Version++;
+	}
+}
diff --git a/Core/Game/Managers/Input/InputManager.cs.meta b/Core/Game/Managers/Input/InputManager.cs.meta
new file mode 100644
index 00000000..7fbae835
--- /dev/null
+++ b/Core/Game/Managers/Input/InputManager.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0d503a1406ad24855933e4f57459670c
+timeCreated: 1441250891
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Managers/Input/MetaActionCode.cs b/Core/Game/Managers/Input/MetaActionCode.cs
new file mode 100644
index 00000000..97a0b23c
--- /dev/null
+++ b/Core/Game/Managers/Input/MetaActionCode.cs
@@ -0,0 +1,3 @@
+public enum MetaActionCode : ushort{
+	NewPlayer
+}
\ No newline at end of file
diff --git a/Core/Game/Managers/Input/MetaActionCode.cs.meta b/Core/Game/Managers/Input/MetaActionCode.cs.meta
new file mode 100644
index 00000000..33928917
--- /dev/null
+++ b/Core/Game/Managers/Input/MetaActionCode.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 64ebd7ceb6fa94eceafe493d13f5d037
+timeCreated: 1443399940
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Managers/LockstepManager.cs b/Core/Game/Managers/LockstepManager.cs
index b021233c..f7462d71 100644
--- a/Core/Game/Managers/LockstepManager.cs
+++ b/Core/Game/Managers/LockstepManager.cs
@@ -23,127 +23,96 @@
 
 using Lockstep.UI;
 using UnityEngine;
-
 //using Lockstep.Integration;
 using Lockstep.Data;
-
-namespace Lockstep
-{
+namespace Lockstep {
     //TODO: Set up default functions to implement LSManager
-    public static class LockstepManager
-    {
-        public static readonly System.Diagnostics.Stopwatch SimulationTimer = new System.Diagnostics.Stopwatch();
-
-        /// <summary>
-        /// Seconds since start if the last session.
-        /// </summary>
-        /// <value>The seconds.</value>
-        public static double Seconds { get { return SimulationTimer.ElapsedTicks / (double)System.TimeSpan.TicksPerSecond; } }
-
-        public static MonoBehaviour UnityInstance { get; private set; }
-
+    public static class LockstepManager {
+		public static readonly System.Diagnostics.Stopwatch SimulationTimer = new System.Diagnostics.Stopwatch();
+		public static long Ticks {get {return SimulationTimer.ElapsedTicks;}}
+		public static MonoBehaviour UnityInstance {get; private set;}
         public const int FrameRate = 32;
         public const int InfluenceResolution = 2;
-        public const float BaseDeltaTime = (float)(1d / FrameRate);
-
-        private static int InfluenceCount;
+		public const float BaseDeltaTime = (float)(1d  / FrameRate);
 
-        public static int InfluenceFrameCount { get; private set; }
+		private static int InfluenceCount;
 
+		public static int InfluenceFrameCount {get; private set;}
         public static int FrameCount { get; private set; }
+		public static bool Started {get; private set;}
+        public static bool Loaded {get; private set;}
 
-        public static bool GameStarted { get; private set; }
+        public static GameManager MainGameManager {get; private set;}
 
-        public static bool Loaded { get; private set; }
+        internal static void Setup () {
 
-        private static GameManager _mainGameManager;
-
-        public static GameManager MainGameManager
-        {
-            get
-            {
-                if (_mainGameManager == null)
-                    throw new System.Exception("MainGameManager has exploded!");
-                return _mainGameManager;
-            }
-            private set
-            {
-                _mainGameManager = value;
-            }
-        }
-
-        internal static void Setup()
-        {
             DefaultMessageRaiser.EarlySetup();
 
-            LSDatabaseManager.Setup();
+            LSDatabaseManager.Setup ();
 
-            UnityInstance = GameObject.CreatePrimitive(PrimitiveType.Quad).AddComponent<MonoBehaviour>();
-            GameObject.Destroy(UnityInstance.GetComponent<Collider>());
+			UnityInstance = GameObject.CreatePrimitive (PrimitiveType.Sphere).AddComponent<MonoBehaviour> ();
             UnityInstance.GetComponent<Renderer>().enabled = false;
-            GameObject.DontDestroyOnLoad(UnityInstance.gameObject);
+			GameObject.DontDestroyOnLoad (UnityInstance.gameObject);
 
             GridManager.Setup();
-            AbilityInterfacer.Setup();
+			AbilityInterfacer.Setup ();
          
             AgentController.Setup();
-            TeamManager.Setup();
+			TeamManager.Setup ();
 
             ProjectileManager.Setup();
             EffectManager.Setup();
 
-            PhysicsManager.Setup();
-            ClientManager.Setup(MainGameManager.MainNetworkHelper);
+			PhysicsManager.Setup ();
+			ClientManager.Setup (MainGameManager.MainNetworkHelper);
+            InterfaceManager.Setup();
 
-            Application.targetFrameRate = 60;
-            Time.fixedDeltaTime = BaseDeltaTime;
-            Time.maximumDeltaTime = Time.fixedDeltaTime * 2;
-            InputCodeManager.Setup();
+			Application.targetFrameRate = 30;
+			Time.fixedDeltaTime = BaseDeltaTime;
+			Time.maximumDeltaTime = Time.fixedDeltaTime * 2;
 
+			InputManager.Setup ();
 
             DefaultMessageRaiser.LateSetup();
         }
 
-        internal static void Initialize(GameManager gameManager)
-        {
-            Application.targetFrameRate = 30;
+        internal static void Initialize(GameManager gameManager) {
             MainGameManager = gameManager;
 
-            if (!Loaded)
-            {
-                Setup();
+            if (!Loaded) {
+                Setup ();
                 Loaded = true;
             }
-            InitializeHelpers();
+            InitializeHelpers ();
 
 
             DefaultMessageRaiser.EarlyInitialize();
-            SimulationTimer.Stop();
-            SimulationTimer.Reset();
-            SimulationTimer.Start();
-            LSDatabaseManager.Initialize();
+
+			SimulationTimer.Reset ();
+			SimulationTimer.Start ();
+			LSDatabaseManager.Initialize();
             LSUtility.Initialize(1);
-            InfluenceCount = 0;
-            Time.timeScale = 1f;
-            Stalled = true;
+			Interfacing.Initialize ();
+			InfluenceCount = 0;
+			Time.timeScale = 1f;
+			Stalled = true;
 
             FrameCount = 0;
-            InfluenceFrameCount = 0;
-            MainGameManager.MainInterfacingHelper.Initialize();
+			InfluenceFrameCount = 0;
 
             TriggerManager.Initialize();
 
             GridManager.Initialize();
 
-            TeamManager.Initialize();
+			TeamManager.Initialize ();
 
             CoroutineManager.Initialize();
-            FrameManager.Initialize();
+			FrameManager.Initialize();
 
             CommandManager.Initialize();
 
             AgentController.Initialize();
-            TeamManager.LateInitialize();
+			TeamManager.LateInitialize ();
 
             PhysicsManager.Initialize();
             PlayerManager.Initialize();
@@ -151,166 +120,159 @@ internal static void Initialize(GameManager gameManager)
             InfluenceManager.Initialize();
             ProjectileManager.Initialize();
 
-            ClientManager.Initialize();
+			Started = true;
+            ClientManager.Initialize ();
+
 
             DefaultMessageRaiser.LateInitialize();
             BehaviourHelperManager.LateInitialize();
-            MainGameManager.MainInterfacingHelper.LateInitialize();
         }
 
-        static void InitializeHelpers()
-        {
+        static void InitializeHelpers () {
             FastList<BehaviourHelper> helpers = new FastList<BehaviourHelper>();
-            MainGameManager.GetBehaviourHelpers(helpers);
-            BehaviourHelperManager.Initialize(helpers.ToArray());
+            MainGameManager.GetBehaviourHelpers (helpers);
+            BehaviourHelperManager.Initialize(helpers.ToArray ());
         }
 
-        static bool Stalled;
-
-        internal static void Simulate()
-        {
-            MainGameManager.MainNetworkHelper.Simulate();
-            DefaultMessageRaiser.EarlySimulate();
-            if (InfluenceCount == 0)
-            {
-                InfluenceSimulate();
-                InfluenceCount = InfluenceResolution - 1;
-                if (FrameManager.CanAdvanceFrame == false)
-                {
-                    Stalled = true;
-                    return;
-                }
-                Stalled = false;
-                if (InfluenceFrameCount == 0)
-                {
-                    GameStart ();
-                }
-                FrameManager.Simulate();
-                InfluenceFrameCount++;
-            } else
-            {
-                InfluenceCount--;
-            }
-            if (Stalled)
-            {
-                return;
-            }
-
-            MainGameManager.MainInterfacingHelper.Simulate();
-
-            BehaviourHelperManager.Simulate();
-            AgentController.Simulate();
+		static bool Stalled;
+        internal static void Simulate() {
+            DefaultMessageRaiser.EarlySimulate ();
+			if (InfluenceCount == 0)
+			{
+				InfluenceSimulate ();
+				InfluenceCount = InfluenceResolution - 1;
+            	if (FrameManager.CanAdvanceFrame == false) {
+					Stalled = true;
+               		return;
+           		}
+				Stalled = false;
+                MainGameManager.GameStart();
+
+				FrameManager.Simulate();
+				InfluenceFrameCount++;
+			}
+			else {
+				InfluenceCount--;
+			}
+			if (Stalled){
+				return;
+			}
+			if (FrameCount == 0) StartGame ();
+			BehaviourHelperManager.Simulate();
+			AgentController.Simulate();
             PhysicsManager.Simulate();
             CoroutineManager.Simulate();
             InfluenceManager.Simulate();
             ProjectileManager.Simulate();
-            TeamManager.Simulate();
+			TeamManager.Simulate ();
 
             TriggerManager.Simulate();
 
-            LateSimulate();
+			LateSimulate ();
             FrameCount++;
 
         }
-
-        private static void GameStart()
-        {
-            GameManager.GameStart();
-            BehaviourHelperManager.GameStart();
-            GameStarted = true;
-
-        }
-
-        private static void LateSimulate()
-        {
-            BehaviourHelperManager.LateSimulate();
-            AgentController.LateSimulate();
-            PhysicsManager.LateSimulate();
-            DefaultMessageRaiser.LateSimulate();
-        }
-
-        internal static void InfluenceSimulate()
-        {
-            PlayerManager.Simulate();
-            CommandManager.Simulate();
-            ClientManager.Simulate();
-        }
-
-        internal static void Execute(Command com)
-        {
-            if (!GameStarted) 
+		private static void StartGame () {
+			GameManager.StartGame ();
+		}
+		private static void LateSimulate () {
+            BehaviourHelperManager.LateSimulate ();
+			AgentController.LateSimulate ();
+			PhysicsManager.LateSimulate ();
+            DefaultMessageRaiser.LateSimulate ();
+		}
+        internal static void InfluenceSimulate () {
+			PlayerManager.Simulate();
+			CommandManager.Simulate();
+			ClientManager.Simulate ();
+		}
+
+        internal static void Execute (Command com) {
+            
+            switch (com.LeInput)
             {
-                Debug.LogError("BOOM");
-                return;
+                case InputCode.None:
+                    break;
+                case InputCode.Meta:
+                    MetaActionCode actionCode = (MetaActionCode)com.Target;
+                    int id = com.Count;
+                    switch (actionCode)
+                    {
+                        case MetaActionCode.NewPlayer:
+                            AgentController controller = new AgentController();
+                            if (id == ClientManager.ID)
+                            {
+                                PlayerManager.AddController(controller);
+                            }
+                            TeamManager.JoinTeam(controller);
+                            
+                            break;
+                    }
+                    break;
+                default:
+                    AgentController cont = AgentController.InstanceManagers [com.ControllerID];
+                    cont.Execute(com);
+                    break;
             }
-            AgentController cont = AgentController.InstanceManagers [com.ControllerID];
-            cont.Execute(com);
-
 
-            DefaultMessageRaiser.Execute(com);
+            DefaultMessageRaiser.Execute (com);
 
         }
 
-        internal static void Visualize()
-        {
-            if (!GameStarted) return;
+        internal static void Visualize() {
             DefaultMessageRaiser.EarlyVisualize();
-            PlayerManager.Visualize();
-            MainGameManager.MainInterfacingHelper.Visualize();
-            BehaviourHelperManager.Visualize();
-            PhysicsManager.Visualize();
-            AgentController.Visualize();
+			PlayerManager.Visualize();
+
+			BehaviourHelperManager.Visualize();
+			PhysicsManager.Visualize();
+			AgentController.Visualize();
             ProjectileManager.Visualize();
             EffectManager.Visualize();
 
-            TeamManager.Visualize();
+			TeamManager.Visualize ();
         }
 
-        internal static void LateVisualize()
-        {
+        internal static void LateVisualize () {
+			InputManager.Visualize();
             DefaultMessageRaiser.LateVisualize();
 
-        }
-
-        internal static void DrawGUI()
-        {
+		}
 
-        }
-
-        internal static void Deactivate()
-        {
+        internal static void Deactivate() {
             DefaultMessageRaiser.EarlyDeactivate();
 
-            if (GameStarted == false)
-                return;
+            if (Started == false) return;
             Selector.Clear();
             AgentController.Deactivate();
-            MainGameManager.MainInterfacingHelper.Deactivate();
-            BehaviourHelperManager.Deactivate();
+			BehaviourHelperManager.Deactivate ();
             ProjectileManager.Deactivate();
-            ClientManager.Deactivate();
+			ClientManager.Deactivate ();
+            LockstepManager.Deactivate();
 
-            TeamManager.Deactivate();
-            ClientManager.Quit();
-            GameStarted = false;
+			TeamManager.Deactivate ();
+            ClientManager.NetworkHelper.Disconnect ();
+			Started = false;
 
             DefaultMessageRaiser.LateDeactivate();
         }
 
-        public static void Quit()
-        {
-            ClientManager.Quit();
-        }
+		public static void Quit () {
+			ClientManager.Quit ();
+		}
 
-        public static int GetStateHash()
-        {
-            int hash = LSUtility.PeekRandom(int.MaxValue);
+        public static int GetStateHash () {
+            int hash = LSUtility.PeekRandom (int.MaxValue);
             hash += 1;
-            hash ^= AgentController.GetStateHash();
+            hash ^= AgentController.GetStateHash ();
             hash += 1;
-            hash ^= ProjectileManager.GetStateHash();
+            hash ^= ProjectileManager.GetStateHash ();
             hash += 1;
             return hash;
         }
     }
+
+    public enum SelectionSetting {
+        PC_RTS,
+        Mobile
+    }
 }
\ No newline at end of file
diff --git a/Core/Game/Managers/Network/NetworkHelper.cs b/Core/Game/Managers/Network/NetworkHelper.cs
index 8649e523..0ad600e5 100644
--- a/Core/Game/Managers/Network/NetworkHelper.cs
+++ b/Core/Game/Managers/Network/NetworkHelper.cs
@@ -2,11 +2,11 @@
 using System.Collections;
 using System;
 
-namespace Lockstep.NetworkHelpers {
-    public abstract class NetworkHelper : MonoBehaviour{
+namespace Lockstep {
+    public abstract class NetworkHelper {
         public abstract bool IsConnected { get; }
 
-        public abstract int ID { get; }
+        public abstract ushort ID { get; }
 
         public abstract bool IsServer { get; }
 
@@ -24,94 +24,60 @@ public NetworkHelper () {
 
         }
 
-        /// <summary>
-        /// Connecting to a server with IP address of ip. Note: Not all NetworkHelpers will require Connect.
-        /// </summary>
-        /// <param name="ip">Ip.</param>
-        public virtual void Connect (string ip) {
-            throw new System.NotImplementedException("Connecting not supported for " + this.ToString() + ".");
-        }
-
-        /// <summary>
-        /// Host a server with the specified address. Note: Not all NetworkHelpers will require hosting.
-        /// </summary>
-        /// <param name="roomSize">Room size.</param>
-        public virtual void Host (int roomSize) {
-            throw new System.NotImplementedException("Hosting not supported for " + this.ToString() + ".");
-        }
+        public abstract void Connect (string ip);
 
-        public virtual void Simulate () {}
+        public abstract void Host (int roomSize);
 
         public abstract void Disconnect ();
 
-        /// <summary>
-        /// Sends the message to server. If this client is the server, automatically sends message directly.
-        /// </summary>
-        /// <param name="messageType">Message type.</param>
-        /// <param name="data">Data.</param>
-        public void SendMessageToServer (MessageType messageType, byte[] data) {
-
-            OnSendMessageToServer (messageType,data);
-        }
-        protected virtual void OnSendMessageToServer (MessageType messageType, byte[] data) {
-            this.Receive (messageType, data);
-        }
+        public abstract void SendMessageToServer (MessageType messageType, byte[] data);
 
         /// <summary>
-        /// Used by the server to send a message to everyone.
+        /// Used by a locally hosted server. 
         /// </summary>
         /// <param name="messageType">Message type.</param>
         /// <param name="data">Data.</param>
-        public void SendMessageToAll (MessageType messageType, byte[] data) {
-            if (this.IsServer) {
-                OnSendMessageToAll (messageType,data);
-            }
-            else {
-                Debug.LogError("Only server can send message to all!");
-            }
-        }
-        protected virtual void OnSendMessageToAll (MessageType messageType, byte[] data) {
-            this.Receive(messageType, data);
-        }
+        public abstract void SendMessageToAll (MessageType messageType, byte[] data);
 
         /// <summary>
-        /// Receives data and sends it to the lockstep frame logic. Call from derived class.
+        /// Call from derived class.
         /// </summary>
         /// <param name="messageType">Message type.</param>
         /// <param name="data">Data.</param>
         protected void Receive (MessageType messageType, byte[] data) {
             if (OnDataReceived != null)
-                OnDataReceived.Invoke (messageType,data);
+                OnDataReceived (messageType,data);
+
             //Huge switch statement for distributing data based on MessageType
             switch (messageType) {
                 case MessageType.Input:
                     if (OnInputData != null) {
-                        OnInputData.Invoke (data);
+                        OnInputData (data);
                     }
                     break;
                 case MessageType.Frame:
                     if (OnFrameData != null) {
-                        OnFrameData.Invoke (data);
+                        OnFrameData (data);
                     }
                     break;
                 case MessageType.Init:
                     if (OnInitData != null) {
-                        OnInitData.Invoke (data);
+                        OnInitData (data);
                     }
                     break;
                 case MessageType.Matchmaking:
                     if (OnMatchmakingData != null) {
-                        OnMatchmakingData.Invoke (data);
+                        OnMatchmakingData (data);
                     }
                     break;
                 case MessageType.Register:
                     if (OnRegisterData != null) {
-                        OnRegisterData.Invoke (data);
+                        OnRegisterData (data);
                     }
                     break;
                 case MessageType.Test:
                     if (OnTestData != null) {
-                        OnTestData.Invoke (data);
+                        OnTestData (data);
                     }
                     break;
             }
diff --git a/Core/Game/Managers/ReplayManager.cs b/Core/Game/Managers/ReplayManager.cs
index 81d45119..7137ff21 100644
--- a/Core/Game/Managers/ReplayManager.cs
+++ b/Core/Game/Managers/ReplayManager.cs
@@ -1,5 +1,3 @@
-//TODO: Reimplement ReplayManager with up-to-date tools
-#if false
 using System;
 using System.IO;
 using System.Collections.Generic;
@@ -9,139 +7,133 @@
 
 namespace Lockstep
 {
-    public static class ReplayManager
-    {
+	public static class ReplayManager
+	{
 
         #region public members
-
-        public static bool IsPlayingBack;
-        public static Replay CurrentReplay;
-
+		public static bool IsPlayingBack;
+		public static Replay CurrentReplay;
         #endregion
 
         #region private members
-
-        private static UnityEngine.Coroutine streamer;
-
+		private static UnityEngine.Coroutine streamer;
         #endregion
 
-        static ReplayManager()
-        {
+		static ReplayManager ()
+		{
 
-        }
+		}
 
         #region public methods
-
-        const string DemoName = "Demo";
-
-        public static void Play()
-        {
-            CurrentReplay = FileManager.RetrieveReplay(DemoName);
-            Play(CurrentReplay);
-        }
-
-        public static void Play(Replay replay)
-        {
-            CommandManager.sendType = SendState.None;
-            IsPlayingBack = true;
-            StartStreaming(replay);
-        }
-
-        public static void Stop()
-        {
-
-            if (IsPlayingBack)
-            {
-                AgentController.Deactivate();
-                IsPlayingBack = false;
-                CommandManager.sendType = CommandManager.defaultSendState;
-                StopStreaming();
-            }
-        }
-
-        public static Replay Save()
-        {
-            return Save(DateTime.UtcNow.ToString());
-        }
-
-        public static Replay Save(string name)
-        {
-            byte[] saveBytes = CommandManager.RecordedBytes.ToArray();
-            CurrentReplay = new Replay();
-            CurrentReplay.Content = saveBytes;
-            CurrentReplay.Name = name;
-            CurrentReplay.Date = DateTime.UtcNow;
-            CurrentReplay.FrameCount = LockstepManager.FrameCount;
-            CurrentReplay.LastCommandedFrameCount = CommandManager.LastCommandedFrameCount;
-            FileManager.SaveReplay(DemoName, CurrentReplay);
-
-            return CurrentReplay;
-        }
-
-        static FastList<byte> bufferBytes = new FastList<byte>();
-
-        public static IEnumerator StreamPlayback(Replay playbackReplay)
-        {
-            int lastFrameByteCount = 0;
-            int playbackPosition = 0;
-            byte[] playbackBytes = playbackReplay.Content;
+		const string DemoName = "Demo";
+
+		public static void Play ()
+		{
+			CurrentReplay = FileManager.RetrieveReplay (DemoName);
+			Play (CurrentReplay);
+		}
+
+		public static void Play (Replay replay)
+		{
+			CommandManager.sendType = SendState.None;
+			IsPlayingBack = true;
+			StartStreaming (replay);
+		}
+
+		public static void Stop ()
+		{
+
+			if (IsPlayingBack)
+			{
+				AgentController.Deactivate ();
+				IsPlayingBack = false;
+				CommandManager.sendType = CommandManager.defaultSendState;
+				StopStreaming ();
+			}
+		}
+
+		public static Replay Save ()
+		{
+			return Save (DateTime.UtcNow.ToString ());
+		}
+
+		public static Replay Save (string name)
+		{
+			byte[] saveBytes = CommandManager.RecordedBytes.ToArray ();
+			CurrentReplay = new Replay ();
+			CurrentReplay.Content = saveBytes;
+			CurrentReplay.Name = name;
+			CurrentReplay.Date = DateTime.UtcNow;
+			CurrentReplay.FrameCount = LockstepManager.FrameCount;
+			CurrentReplay.LastCommandedFrameCount = CommandManager.LastCommandedFrameCount;
+			FileManager.SaveReplay (DemoName, CurrentReplay);
+
+			return CurrentReplay;
+		}
+
+		static FastList<byte> bufferBytes = new FastList<byte> ();
+
+		public static IEnumerator StreamPlayback (Replay playbackReplay)
+		{
+			int lastFrameByteCount = 0;
+			int playbackPosition = 0;
+			byte[] playbackBytes = playbackReplay.Content;
             
             bool getNextStream = true;
-            int frameCount = 0;
-            int nextFrame = -1;
+			int frameCount = 0;
+			int nextFrame = -1;
             
             
-            yield return null;
-            FrameManager.EndFrame = playbackReplay.LastCommandedFrameCount;
+			yield return null;
+			FrameManager.EndFrame = playbackReplay.LastCommandedFrameCount;
             
             while (playbackPosition < playbackBytes.Length || frameCount <= nextFrame)
-            {
-                if (getNextStream == true)
+			{
+				if (getNextStream == true)
                 {
-                    bufferBytes.FastClear();
-                    lastFrameByteCount = (int)BitConverter.ToUInt16(playbackBytes, playbackPosition);
-                    playbackPosition += 2;
-                    nextFrame = BitConverter.ToInt32(playbackBytes, playbackPosition);
-                    bufferBytes.AddRange(playbackBytes, playbackPosition, lastFrameByteCount);
-                    playbackPosition += lastFrameByteCount;
-                    getNextStream = false;
-                }
-
-                if (nextFrame == frameCount)
-                {
-                    getNextStream = true;
-                    CommandManager.ProcessPacket (bufferBytes);
-                }
-                else {
-                    CommandManager.ProcessPacket (BitConverter.GetBytes (frameCount));
+					bufferBytes.FastClear ();
+		            lastFrameByteCount = (int)BitConverter.ToUInt16 (playbackBytes, playbackPosition);
+					playbackPosition += 2;
+					nextFrame = BitConverter.ToInt32 (playbackBytes, playbackPosition);
+					bufferBytes.AddRange (playbackBytes, playbackPosition, lastFrameByteCount);
+					playbackPosition += lastFrameByteCount;
+					getNextStream = false;
+				}
+
+				if (nextFrame == frameCount)
+				{
+					getNextStream = true;
+					CommandManager.ProcessPacket (bufferBytes);
+				}
+				else {
+					CommandManager.ProcessPacket (BitConverter.GetBytes (frameCount));
                 }
                 frameCount++;
-            }
-            yield break;
-        }
-
-
-        private static void StartStreaming (Replay replay)
-        {
-            StopStreaming ();
-            streamer = LockstepManager.UnityInstance.StartCoroutine (StreamPlayback (replay));
-        }
-
-        private static void StopStreaming ()
-        {
-            if (streamer .IsNotNull ()) {
-                LockstepManager.UnityInstance.StopCoroutine (streamer);
-                streamer = null;
-            }
-        }
+			}
+			yield break;
+		}
+
+
+		private static void StartStreaming (Replay replay)
+		{
+			StopStreaming ();
+			streamer = LockstepManager.UnityInstance.StartCoroutine (StreamPlayback (replay));
+		}
+
+		private static void StopStreaming ()
+		{
+			if (streamer .IsNotNull ()) {
+				LockstepManager.UnityInstance.StopCoroutine (streamer);
+				streamer = null;
+			}
+		}
         #endregion
-    }
+	}
     
-    public enum RecordState
-    {
-        None,
-        Record,
-        Playback
-    }
-}
-#endif
\ No newline at end of file
+	public enum RecordState
+	{
+		None,
+		Record,
+		Playback
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Managers/ServerSimulator.cs b/Core/Game/Managers/ServerSimulator.cs
index 6991e552..8810a095 100644
--- a/Core/Game/Managers/ServerSimulator.cs
+++ b/Core/Game/Managers/ServerSimulator.cs
@@ -54,7 +54,7 @@ static IEnumerator Tick ()
 			float accumulator = 0;
 			while (true)
 			{
-				if (IsSimulating && LockstepManager.GameStarted) {
+				if (IsSimulating && LockstepManager.Started) {
 					bufferBytes.FastClear ();
 					bufferBytes.AddRange (BitConverter.GetBytes (InfluenceFrameCount));
 					InfluenceFrameCount++;
diff --git a/Core/Game/Networking/NetworkHelperTester.cs b/Core/Game/Networking/NetworkHelperTester.cs
index 17b7dc84..57e2b09b 100644
--- a/Core/Game/Networking/NetworkHelperTester.cs
+++ b/Core/Game/Networking/NetworkHelperTester.cs
@@ -15,8 +15,7 @@ void OnGUI () {
             }
             #region Setting IP and RoomSize via GUI
             GUILayout.BeginVertical(GUILayout.Width(300f));
-            GUILayout.Label("Time: " + Time.time.ToString());
-            GUI.color = Color.white;
+            GUI.color = Color.black;
             GUILayout.Label("IP: ");
             IP = GUILayout.TextField(IP);
 
diff --git a/Core/Game/Player/Command.cs b/Core/Game/Player/Command.cs
new file mode 100644
index 00000000..18af4bed
--- /dev/null
+++ b/Core/Game/Player/Command.cs
@@ -0,0 +1,281 @@
+namespace Lockstep {
+    public class Command {
+        private const int CompressionShift = FixedMath.SHIFT_AMOUNT - 7;
+        private const int FloatToInt = 100;
+        private const float IntToFloat = 1f / FloatToInt;
+
+        private static uint ValuesMask;
+        private static readonly FastList<byte> serializeList = new FastList<byte>();
+        private static readonly Writer writer = new Writer(serializeList);
+        private static readonly Reader reader = new Reader();
+
+        private Vector2d _position;
+        private ushort _target;
+        private bool _flag;
+        private Coordinate _coord;
+        private int _count;
+        private Selection _select;
+        private byte _groupID;
+        private string _text;
+        private VectorRotation _rotation;
+        private byte[] _raw;
+
+        public bool HasPosition { get; private set; }
+        public bool HasTarget { get; private set; }
+        public bool HasFlag { get; private set; }
+        public bool HasCoord { get; private set; }
+        public bool HasCount { get; private set; }
+        public bool HasSelect { get; set; }
+        public bool HasGroupID { get; private set; }
+        public bool HasText {get; private set;}
+        public bool HasRotation {get; private set;}
+        public bool HasRaw {get; private set;}
+
+        public bool Used;
+        public byte ControllerID;
+        public InputCode LeInput;
+
+        public Command() {}
+
+        public Command(InputCode inputCode) {
+            LeInput = inputCode;
+        }
+		public Command(InputCode inputCode, byte controllerID) {
+			this.LeInput = inputCode;
+			this.ControllerID = controllerID;
+		}
+        public Vector2d Position {
+            get { return _position; }
+            set {
+                _position = value;
+                HasPosition = true;
+            }
+        }
+
+        public ushort Target {
+            get { return _target; }
+            set {
+                _target = value;
+                HasTarget = true;
+            }
+        }
+
+        public bool Flag {
+            get { return _flag; }
+            set {
+                _flag = value;
+                HasFlag = true;
+            }
+        }
+
+        public Coordinate Coord {
+            get { return _coord; }
+            set {
+                _coord = value;
+                HasCoord = true;
+            }
+        }
+
+        public int Count {
+            get { return _count; }
+            set {
+                _count = value;
+                HasCount = true;
+            }
+        }
+
+        public Selection Select {
+            get { return _select; }
+            set {
+                _select = value;
+                HasSelect = true;
+            }
+        }
+
+        public byte GroupID {
+            get { return _groupID; }
+            set {
+                _groupID = value;
+                HasGroupID = true;
+            }
+        }
+
+        public string Text {
+            get {return _text;}
+            set {
+                this._text = value;
+                this.HasText = true;
+            }
+        }
+
+        public VectorRotation Rotation {
+            get {return _rotation;}
+            set {
+                _rotation = value;
+                HasRotation = true;
+            }
+        }
+        public byte[] Raw {
+            get {return _raw;}
+            set {
+                _raw = value;
+                HasRaw = true;
+            }
+        }
+
+        /// <summary>
+        /// Reconstructs this command from a serialized command and returns the size of the command.
+        /// </summary>
+        public int Reconstruct(byte[] Source, int StartIndex) {
+            Used = false;
+            reader.Initialize(Source, StartIndex);
+            ControllerID = reader.ReadByte();
+            LeInput = (InputCode)reader.ReadByte();
+            ValuesMask = reader.ReadUInt();
+
+            HasPosition = GetMaskBool(ValuesMask, DataType.Position);
+            HasTarget = GetMaskBool(ValuesMask, DataType.Target);
+            HasFlag = GetMaskBool(ValuesMask, DataType.Flag);
+            HasCoord = GetMaskBool(ValuesMask, DataType.Coord);
+            HasCount = GetMaskBool(ValuesMask, DataType.Count);
+            HasSelect = GetMaskBool(ValuesMask, DataType.Select);
+            HasGroupID = GetMaskBool(ValuesMask, DataType.GroupID);
+            HasText = GetMaskBool (ValuesMask, DataType.Text);
+            HasRotation = GetMaskBool (ValuesMask, DataType.Rotation);
+            HasRaw = GetMaskBool (ValuesMask, DataType.Raw);
+
+            if (HasPosition) {
+                _position.x = reader.ReadShort() << CompressionShift;
+                _position.y = reader.ReadShort() << CompressionShift;
+            }
+
+            if (HasTarget) {
+                _target = reader.ReadUShort();
+            }
+
+            if (HasFlag) {
+                _flag = reader.ReadBool();
+            }
+
+            if (HasCoord) {
+                _coord.x = reader.ReadInt();
+                _coord.y = reader.ReadInt();
+            }
+
+            if (HasCount) {
+                _count = reader.ReadInt();
+            }
+
+            if (HasSelect) {
+                Select = new Selection();
+                reader.MovePosition (Select.Reconstruct(reader.Source, reader.Position));
+            }
+
+            if (HasGroupID) {
+                _groupID = reader.ReadByte();
+            }
+
+            if (HasText) {
+                _text = reader.ReadString ();
+            }
+
+            if (HasRotation) {
+                _rotation = new VectorRotation (reader.ReadLong(), reader.ReadLong());
+            }
+
+            if (HasRaw) {
+                _raw = reader.ReadByteArray();
+            }
+
+            return reader.Position - StartIndex;
+        }
+
+        private static bool GetMaskBool(uint mask, DataType dataType) {
+            return (mask & (uint)dataType) == (uint)dataType;
+        }
+
+        public byte[] Serialized {
+            get {
+                serializeList.FastClear();
+
+                //Essential Information
+                writer.Write(ControllerID);
+                writer.Write((byte)LeInput);
+
+                //Header 
+                DataType valueMaskDataType = 
+                    (HasPosition ? DataType.Position : 0)
+                    | (HasTarget ? DataType.Target : 0) 
+                    | (HasFlag ? DataType.Flag : 0) 
+                    | (HasCoord ? DataType.Coord : 0) 
+                    | (HasCount ? DataType.Count : 0) 
+                    | (HasSelect ? DataType.Select : 0) 
+                    | (HasGroupID ? DataType.GroupID : 0)
+                    | (HasText ?  DataType.Text : 0)
+                    | (HasRotation ? DataType.Rotation : 0);
+
+                ValuesMask = (uint) valueMaskDataType;
+
+                writer.Write(ValuesMask);
+
+                if (HasPosition) {
+                    writer.Write((short)(_position.x >> CompressionShift));
+                    writer.Write((short)(_position.y >> CompressionShift));
+                }
+
+                if (HasTarget) {
+                    writer.Write(_target);
+                }
+
+                if (HasFlag) {
+                    writer.Write(_flag);
+                }
+
+                if (HasCoord) {
+                    writer.Write(_coord.x);
+                    writer.Write(_coord.y);
+                }
+
+                if (HasCount) {
+                    writer.Write(_count);
+                }
+
+                if (HasSelect) {
+                    writer.Write(_select.Header);
+					for (int i = 0; i < 64; i++) {
+                        if (_select.Data[i] != 0) {
+                            writer.Write(_select.Data[i]);
+                        }
+                    }
+                }
+
+                if (HasGroupID) {
+					writer.Write (_groupID);
+                }
+
+                if (HasText) {
+                    writer.Write(_text);
+                }
+
+                if (HasRotation) {
+                    writer.Write(_rotation.Cos);
+                    writer.Write(_rotation.Sin);
+                }
+                return serializeList.ToArray();
+            }
+        }
+    }
+    [System.Flags]
+    public enum DataType : uint {
+        Position = 1 << 0,
+        Target = 1 << 1,
+        Flag = 1 << 2,
+        Coord = 1 << 3,
+        Count = 1 << 4,
+        Select = 1 << 5,
+        GroupID = 1 << 6,
+        Text = 1 << 7,
+        Rotation = 1 << 8,
+        Raw = 1 << 9,
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Command.cs.meta b/Core/Game/Player/Command.cs.meta
similarity index 100%
rename from Core/Game/Player/Commands/Command.cs.meta
rename to Core/Game/Player/Command.cs.meta
diff --git a/Core/Game/Player/CommandCard.cs b/Core/Game/Player/CommandCard.cs
new file mode 100644
index 00000000..1eb93112
--- /dev/null
+++ b/Core/Game/Player/CommandCard.cs
@@ -0,0 +1,71 @@
+using UnityEngine;
+using System.Collections;
+using System;
+using UnityEngine.UI;
+using System.Collections.Generic;
+using Lockstep.Data;
+namespace Lockstep {
+	[ExecuteInEditMode]
+	public class CommandCard : MonoBehaviour {
+		void Start () {
+
+		}
+
+		public const int Width = 4;
+		public const int Height = 3;
+
+
+		static CommandTile[] Tiles;
+		public void Setup () {
+			Tiles = GetComponentsInChildren<CommandTile> ();
+		
+			for (int i = 0; i < Tiles.Length; i++)
+			{
+				CommandTile tile = Tiles[i];
+				if (tile .IsNotNull ())
+				{
+					tile.Setup (i);
+					tile.OnActivate += HandleTileActivation;
+				}
+			}
+		}
+
+		private static void HandleTileActivation (int tileID) {
+
+		}
+
+		public static void Inject (FastList<AbilityInterfacer> interfacers)
+		{
+			for (int i = 0; i < interfacers.Count; i++)
+			{
+
+				AbilityInterfacer facer = interfacers[i];
+				int tileIndex = facer.TileIndex;
+                if (Tiles == null || tileIndex >= 12 || tileIndex >= Tiles.Length) continue;
+
+				Tiles[tileIndex].Interfacer = (facer);
+			}
+		}
+
+		public static void Visualize () {
+			if (Tiles .IsNotNull ()) {
+				for (int i = 0; i < Tiles.Length; i++)
+				{
+					if (Tiles[i] .IsNotNull ())
+					Tiles[i].Visualize ();
+				}
+			}
+		}
+
+		public static void Reset ()
+		{
+			if (Tiles .IsNotNull ())
+			for (int i = 0; i < Tiles.Length; i++)
+			{
+				Tiles[i].ResetTile ();
+			}
+		}
+
+
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/CommandCard.cs.meta b/Core/Game/Player/CommandCard.cs.meta
new file mode 100644
index 00000000..ebfcffb4
--- /dev/null
+++ b/Core/Game/Player/CommandCard.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6d9f6b6387f944a799db605246a127fd
+timeCreated: 1448496894
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Player/CommandTile.cs b/Core/Game/Player/CommandTile.cs
new file mode 100644
index 00000000..4abffb63
--- /dev/null
+++ b/Core/Game/Player/CommandTile.cs
@@ -0,0 +1,65 @@
+using UnityEngine;
+using System.Collections;
+using UnityEngine.UI;
+using System;
+using Lockstep.Data;
+namespace Lockstep {
+	public class CommandTile : CerealBehaviour {
+		[SerializeField]
+		private Button _button;
+		public Button LeButton{get {return _button;}}
+		[SerializeField]
+		private Image _image;
+		public Image LeImage {get {return _image;}}
+		public int ID {get; private set;}
+
+		private AbilityInterfacer _interfacer;
+		public AbilityInterfacer Interfacer {get {return _interfacer;}
+			set {
+				if (value != _interfacer)
+				{
+					gameObject.SetActiveIfNot (true);
+					LeImage.sprite = value.Icon;
+					_interfacer = value;
+				}
+			}
+		}
+
+		public void Setup (int id) {
+			ID = id;
+			_button.onClick.AddListener (Activate);
+			ResetTile ();
+		}
+
+		public void Visualize () {
+			if (Interfacer .IsNotNull ())
+			{
+				if (InputManager.GetInputDown (Interfacer.ListenInput))
+				{
+					Activate ();
+				}
+			}
+		}
+
+		public void ResetTile ()
+		{
+			if (this == null) return;
+			gameObject.SetActiveIfNot (false);
+			_interfacer = null;
+		}
+
+		private void Activate () {
+			OnActivate (ID);
+			InterfaceManager.CurrentInterfacer = Interfacer;
+		}
+
+		public event Action<int> OnActivate;
+#if UNITY_EDITOR
+        protected override void OnAfterSerialize  ()
+		{
+			_image = this.GetComponentInChildrenOrderered<Image> ();
+			_button = GetComponent<Button> ();
+		}
+#endif
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/CommandTile.cs.meta b/Core/Game/Player/CommandTile.cs.meta
new file mode 100644
index 00000000..2af0a101
--- /dev/null
+++ b/Core/Game/Player/CommandTile.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0f59308d20f4548e1a77f6b82302e300
+timeCreated: 1441308252
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Player/Commands/BackwardsCommand.cs b/Core/Game/Player/Commands/BackwardsCommand.cs
deleted file mode 100644
index 66be55c8..00000000
--- a/Core/Game/Player/Commands/BackwardsCommand.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-using UnityEngine;
-using System.Collections;
-
-namespace Lockstep
-{
-    public partial class Command
-    {
-
-        static void RegisterBackwards()
-        {
-            Register<PositionData>();
-            Register<TargetData>();
-            Register<FlagData>();
-            Register<CoordinateData>();
-            Register<CountData>();
-        }
-
-        public Vector2d Position
-        {
-            get { return this.GetData<PositionData>().position; }
-            set { this.SetFirstData <PositionData>(new PositionData(value)); }
-        }
-
-        public bool HasPosition { get { return this.ContainsData<PositionData>(); } }
-
-        class PositionData : ICommandData
-        {
-            public PositionData(Vector2d pos)
-            {
-                position = pos;
-            }
-
-            public Vector2d position;
-
-            public void Write(Writer writer)
-            {
-                position.Write(writer);
-            }
-
-            public void Read(Reader reader)
-            {
-                position.Read(reader);
-            }
-        }
-
-        public ushort Target
-        {
-            get { return (ushort)this.GetData<TargetData>().Value; }
-            set { this.SetFirstData<TargetData>(new TargetData(value)); }
-        }
-
-        public bool HasTarget { get { return this.ContainsData<TargetData>(); } }
-
-        class TargetData : DefaultData
-        {
-            public TargetData(ushort value) : base(DataType.UShort, (object)value)
-            {
-            }
-        }
-
-        public bool Flag
-        {
-            get { return (bool)this.GetData<FlagData>().Value; }
-            set { this.SetFirstData<FlagData>(new FlagData(value)); }
-        }
-
-        public bool HasFlag { get { return this.ContainsData<FlagData>(); } }
-
-        class FlagData : DefaultData
-        {
-            public FlagData(bool value) : base(DataType.Bool, value)
-            {
-            }
-        }
-
-        public Coordinate Coord
-        {
-            get { return this.GetData<CoordinateData>().coordinate; }
-            set { this.SetFirstData<CoordinateData>(new CoordinateData(value)); }
-        }
-
-        public bool HasCoord { get { return this.ContainsData<CoordinateData>(); } }
-
-        class CoordinateData : ICommandData
-        {
-            public CoordinateData(Coordinate coord)
-            {
-                this.coordinate = coord;
-            }
-
-            public Coordinate coordinate;
-
-            public void Write(Writer writer)
-            {
-                coordinate.Write(writer);
-            }
-
-            public void Read(Reader reader)
-            {
-                coordinate.Read(reader);
-            }
-        }
-
-        public int Count
-        {
-            get { return (int)this.GetData<CountData>().Value; }
-            set { this.SetFirstData<CountData>(new CountData(value)); }
-        }
-
-        public bool HasCount { get { return this.ContainsData<CountData>(); } }
-
-        class CountData : DefaultData
-        {
-            public CountData(int value) : base(DataType.Int, value)
-            {
-            }
-        }
-      
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Command.cs b/Core/Game/Player/Commands/Command.cs
deleted file mode 100644
index afb774e9..00000000
--- a/Core/Game/Player/Commands/Command.cs
+++ /dev/null
@@ -1,218 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Lockstep
-{
-    public partial class Command
-    {
-
-        static Command () {
-            RegisterDefaults ();
-            RegisterBackwards ();
-        }
-
-        private const int CompressionShift = FixedMath.SHIFT_AMOUNT - 7;
-        private const int FloatToInt = 100;
-        private const float IntToFloat = 1f / FloatToInt;
-
-
-        private static readonly FastList<byte> serializeList = new FastList<byte>();
-        private static readonly Writer writer = new Writer(serializeList);
-        private static readonly Reader reader = new Reader();
-
-        private static ushort RegisterCount;
-
-        private static BiDictionary<Type, ushort> RegisteredData = new BiDictionary<Type, ushort>();
-
-        static void RegisterDefaults () {
-            Register<DefaultData> ();
-            Register<Vector2d> ();
-            Register<Selection> ();
-            Register<Vector2dHeight> ();
-            Register<Coordinate> ();
-        }
-
-        public static void Register<TData>() where TData : ICommandData
-        {
-            if (RegisterCount > ushort.MaxValue)
-            {
-                throw new System.Exception(string.Format("Cannot register more than {0} types of data.", ushort.MaxValue + 1));
-            }
-            if (RegisteredData.ContainsKey(typeof(TData))) return;
-            RegisteredData.Add(typeof(TData), RegisterCount++);
-        }
-
-        public byte ControllerID;
-        public ushort LeInput;
-        private Dictionary<ushort,FastList<ICommandData>> ContainedData = new Dictionary<ushort,FastList<ICommandData>>();
-        private ushort ContainedTypesCount;
-
-
-        public Command()
-        {
-        }
-
-        public Command(ushort inputCode)
-        {
-            this.Initialize();
-            LeInput = inputCode;
-        }
-
-        public Command(ushort inputCode, byte controllerID)
-        {
-            this.Initialize();
-            this.LeInput = inputCode;
-            this.ControllerID = controllerID;
-        }
-
-        public void Initialize()
-        {
-            ContainedData.Clear();
-            ContainedTypesCount = 0;
-        }
-
-        public void Add<TData>(params TData[] addItems) where TData : ICommandData
-        {
-            for (int i = 0; i < addItems.Length; i++)
-                Add(addItems [i]);
-        }
-
-        public void Add<TData>(TData item) where TData : ICommandData
-        {
-            ushort dataID;
-            if (RegisteredData.TryGetValue(typeof(TData), out dataID))
-            {
-                FastList<ICommandData> items = GetItemsList(dataID);
-                if (items.Count == ushort.MaxValue)
-                {
-                    throw new Exception("No more than '{0}' of a type can be added to a Command.");
-                }
-                if (items.Count == 0)
-                    ContainedTypesCount++;
-                items.Add(item);
-            } else
-            {
-                throw new System.Exception(string.Format("Type '{0}' not registered.", typeof(TData)));
-            }
-        }
-
-        public bool ContainsData <TData>()
-        {
-            return GetDataCount<TData> () > 0;
-        }
-
-        public int GetDataCount <TData>()
-        {
-            ushort dataID;
-            if (!RegisteredData.TryGetValue(typeof(TData), out dataID))
-                return 0;
-            FastList<ICommandData> items;
-            if (!ContainedData.TryGetValue(dataID, out items))
-            {
-                return 0;
-            }
-            return items.Count;
-        }
-
-        public TData GetData <TData>(int index = 0) where TData : ICommandData
-        {
-            return (TData)this.ContainedData [RegisteredData [typeof(TData)]] [index];
-        }
-        public bool TryGetData<TData> (out TData data, int index = 0) where TData : ICommandData
-        {
-            data = default(TData);
-            ushort dataID;
-            if (!RegisteredData.TryGetValue (typeof (TData), out dataID)) return false;
-            FastList<ICommandData> items;
-            if (!this.ContainedData.TryGetValue(dataID, out items)) return false;
-            if (items.Count <= index) return false;
-            data = (TData)items[index];
-            return true;
-        }
-
-        public void SetData<TData> (TData value, int index = 0) where TData : ICommandData
-        {
-            this.ContainedData[RegisteredData[typeof(TData)]][index] = value;
-        }
-
-        public bool SetFirstData<TData> (TData value) where TData : ICommandData
-        {
-            ushort dataID;
-            if (!RegisteredData.TryGetValue (typeof (TData), out dataID)) return false;
-            FastList<ICommandData> items;
-            if (!this.ContainedData.TryGetValue(dataID, out items)) return false;
-            if(items.Count == 0)
-                items.Add(value);
-            else
-                items[0] = value;
-            return true;
-        }
-        public void ClearData<TData> () {
-            this.ContainedData[RegisteredData[typeof(TData)]].Clear();
-        }
-
-        /// <summary>
-        /// Reconstructs this command from a serialized command and returns the size of the command.
-        /// </summary>
-        public int Reconstruct(byte[] Source, int StartIndex = 0)
-        {
-            reader.Initialize(Source, StartIndex);
-            ControllerID = reader.ReadByte();
-            LeInput = reader.ReadUShort();
-            this.ContainedTypesCount = reader.ReadUShort();
-
-            for (int i = 0; i < this.ContainedTypesCount; i++)
-            {
-                ushort dataID = reader.ReadUShort();
-                ushort dataCount = reader.ReadUShort();
-                FastList<ICommandData> items = GetItemsList(dataID);
-                Type dataType = RegisteredData.GetReversed(dataID);
-                for (int j = 0; j < dataCount; j++)
-                {
-                    ICommandData item = Activator.CreateInstance(dataType) as ICommandData;
-                    item.Read(reader);
-                    items.Add(item);
-                }
-            }
-
-            return reader.Position - StartIndex;
-        }
-
-
-        public byte[] Serialized
-        {
-            get
-            {
-                writer.Reset();
-                
-
-                //Essential Information
-                writer.Write(ControllerID);
-                writer.Write(LeInput);
-                writer.Write(ContainedTypesCount);
-                foreach (KeyValuePair<ushort,FastList<ICommandData>> pair in ContainedData)
-                {
-                    writer.Write(pair.Key);
-                    writer.Write((ushort)pair.Value.Count);
-                    for (int i = 0; i < pair.Value.Count; i++)
-                    {
-                        pair.Value [i].Write(writer);
-                    }
-                }
-
-                return serializeList.ToArray();
-            }
-        }
-
-        FastList<ICommandData> GetItemsList(ushort dataID)
-        {
-            FastList<ICommandData> items;
-            if (!ContainedData.TryGetValue(dataID, out items))
-            {
-                items = new FastList<ICommandData>();
-                ContainedData.Add(dataID, items);
-            }
-            return items;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/CommandManager.cs b/Core/Game/Player/Commands/CommandManager.cs
deleted file mode 100644
index 5e38536f..00000000
--- a/Core/Game/Player/Commands/CommandManager.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-using System;
-using UnityEngine;
-
-namespace Lockstep
-{
-    public static class CommandManager
-    {
-        const int defaultSize = 1000;
-
-        public static int LastCommandedFrameCount { get; private set; }
-
-        #region Recording
-
-        public static FastList<byte> RecordedBytes = new FastList<byte>(defaultSize);
-
-        #endregion
-
-        static readonly FastList<Command> outCommands = new FastList<Command>(defaultSize);
-        static readonly FastList<byte> bufferedBytes = new FastList<byte>(256);
-
-        public static void Initialize()
-        {
-            RecordedBytes.FastClear();
-            outCommands.FastClear();
-            LastCommandedFrameCount = -1;
-        }
-
-        public static void Simulate()
-        {
-            SendOut ();
-        }
-
-        public static void ProcessPacket(byte[] packet)
-        {
-            processBytes.FastClear();
-            processBytes.AddRange(packet);
-            ProcessPacket(processBytes);
-        }
-
-        static FastList<byte> processBytes = new FastList<byte>();
-
-        public static void ProcessPacket(FastList<byte> packet)
-        {
-
-            if (packet == null || packet.Count < 4)
-            {
-                throw new System.Exception("Packet is null or not valid length");
-            }
-            int frameCount = BitConverter.ToInt32(packet.innerArray, 0);
-            int index = 4;
-
-            if (FrameManager.HasFrame(frameCount) == false)
-            {
-                Frame frame = new Frame();
-
-                if (packet.Count > 4)
-                {
-                    RecordedBytes.AddRange(BitConverter.GetBytes((ushort)packet.Count));
-                    RecordedBytes.AddRange(packet);
-                    while (index < packet.Count)
-                    {
-                        Command com = new Command();
-                        index += com.Reconstruct(packet.innerArray, index);
-                        frame.AddCommand(com);
-                    }
-                    if (frameCount > LastCommandedFrameCount)
-                    {
-                        LastCommandedFrameCount = frameCount;
-                    }
-                }
-                FrameManager.AddFrame(frameCount, frame);
-
-            } else
-            {
-
-            }
-        }
-
-        /// <summary>
-        /// Sends out all Commands
-        /// </summary>
-        public static void SendOut () {
-            if (outCommands.Count > 0) {
-                bufferedBytes.FastClear();
-
-                for (int i = 0; i < outCommands.Count; i++)
-                {
-                    bufferedBytes.AddRange(outCommands [i].Serialized);
-                }
-                if (bufferedBytes.Count > 0)
-                    ClientManager.Distribute(bufferedBytes.ToArray());
-
-                outCommands.FastClear();
-            }
-        }
-
-        public static void SendCommand(Command com, bool immediate = false)
-        {
-            outCommands.Add(com);
-            if (immediate)
-            {
-                SendOut ();
-            }
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Default/BaseSerializableValue.cs b/Core/Game/Player/Commands/Default/BaseSerializableValue.cs
deleted file mode 100644
index f80c939d..00000000
--- a/Core/Game/Player/Commands/Default/BaseSerializableValue.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using System;
-using System.IO;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Collections.Generic;
-namespace Lockstep
-{
-    public abstract class BaseSerializableValue : Lockstep.ICommandData
-    {
-        protected static readonly BinaryFormatter binaryFormatter = new BinaryFormatter();
-
-        public abstract object ObjectValue {get;protected set;}
-
-        public void Write(Writer writer)
-        {
-            using (MemoryStream stream = new MemoryStream()) {
-                binaryFormatter.Serialize(stream, this.ObjectValue);
-                byte[] streamBytes = stream.ToArray();
-                ushort size = (ushort)streamBytes.Length;
-                writer.Write(size);
-                writer.Write(streamBytes);
-            }
-        }
-        public void Read (Reader reader) {
-            ushort size = reader.ReadUShort(); 
-            using (MemoryStream stream = new MemoryStream(reader.Source,reader.Position,(int)size)){
-                object o = binaryFormatter.Deserialize(stream);
-                this.ObjectValue = (object[])o;
-            }
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Default/DefaultData.cs b/Core/Game/Player/Commands/Default/DefaultData.cs
deleted file mode 100644
index f53e4425..00000000
--- a/Core/Game/Player/Commands/Default/DefaultData.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using System;
-using System.Text;
-
-namespace Lockstep
-{
-    public class DefaultData : ICommandData
-    {
-        public DefaultData () {}
-        public DefaultData(DataType dataType, object value)
-        {
-            Value = value;
-            this.DataType = dataType;
-        }
-
-        public DefaultData(object value)
-        {
-            Value = value;
-            this.DataType = GetDataType(value.GetType());
-        }
-
-        public object Value { get; protected set; }
-
-        public DataType DataType { get; protected set; }
-
-        public bool Is(DataType dataType)
-        {
-            return this.DataType == dataType;
-        }
-
-        public DataType GetDataType(Type type)
-        {
-            if (type == typeof(int))
-                return DataType.Int;
-            if (type == typeof(ushort))
-                return DataType.UShort;
-            if (type == typeof(long))
-                return DataType.Long;
-            if (type == typeof(byte))
-                return DataType.Byte;
-            if (type == typeof(string))
-                return DataType.String;
-            if (type == typeof(byte[]))
-                return DataType.ByteArray;
-            throw new System.Exception(string.Format("Type '{0}' is not a valid DefaultData Type.", type));
-        }
-
-        public void Write(Writer writer)
-        {
-            writer.Write((byte)this.DataType);
-            switch (this.DataType)
-            {
-                case DataType.Int:
-                    writer.Write((int)Value);
-                    break;
-                case DataType.UShort:
-                    writer.Write((ushort)Value);
-                    break;
-                case DataType.Long:
-                    writer.Write((long)Value);
-                    break;
-                case DataType.Byte:
-                    writer.Write((byte)Value);
-                    break;
-                case DataType.Bool:
-                    writer.Write((bool)Value);
-                    break;
-                case DataType.String:
-                    writer.Write((string)Value);
-                    break;
-                case DataType.ByteArray:
-                    writer.WriteByteArray((byte[])Value);
-                    break;
-            }
-        }
-
-
-        public void Read(Reader reader)
-        {
-            this.DataType = (DataType)reader.ReadByte();
-            switch (this.DataType)
-            {
-                case DataType.Int:
-                    Value = reader.ReadInt();
-                    break;
-                case DataType.UShort:
-                    Value = reader.ReadUShort();
-                    break;
-                case DataType.Long:
-                    Value = reader.ReadLong();
-                    break;
-                case DataType.Byte:
-                    Value = reader.ReadByte();
-                    break;
-                case DataType.Bool:
-                    Value = reader.ReadBool();
-                    break;
-                case DataType.String:
-                    Value = reader.ReadString();
-                    break;
-                case DataType.ByteArray:
-                    Value = reader.ReadByteArray();
-                    break;
-            }
-        }
-    }
-
-    public enum DataType : byte
-    {
-        Int,
-        UShort,
-        Long,
-        Byte,
-        Bool,
-        String,
-        ByteArray,
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Default/SerializableValue.cs b/Core/Game/Player/Commands/Default/SerializableValue.cs
deleted file mode 100644
index dad09209..00000000
--- a/Core/Game/Player/Commands/Default/SerializableValue.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using System.Runtime.Serialization.Formatters.Binary;
-using System;
-using System.Runtime.Serialization;
-using System.Collections.Generic;
-using System.Collections;
-using System.Collections.ObjectModel;
-using System.Linq;
-
-namespace Lockstep
-{
-    public class SerializableValue<TValue> : BaseSerializableValue where TValue : new()
-    {
-        public SerializableValue(TValue value)
-        {
-            if (typeof(TValue).IsSerializable || typeof(TValue).IsAssignableFrom(typeof(ISerializable)))
-            {
-                Value = value;
-            } else
-            {
-                throw new InvalidOperationException("A serializable Type is required");
-            }
-        }
-
-        private TValue Value;
-
-        private TValue _ObjectValue
-        {
-            get
-            {
-                return Value;
-            }
-            set {
-                Value = value;
-            }
-        }
-
-        public override object ObjectValue
-        {
-            get
-            {
-                return (object)this._ObjectValue;
-            }
-            protected set {
-                _ObjectValue = (TValue)value;
-            }
-        }
-
-      
-
-        public static implicit operator TValue(SerializableValue<TValue> serializable)
-        {
-            return serializable._ObjectValue;
-        }
-
-        public static implicit operator SerializableValue<TValue>(TValue value)
-        {
-            SerializableValue<TValue> serializable = new SerializableValue<TValue>(value);
-            return serializable;
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/Default/SerializableValue.cs.meta b/Core/Game/Player/Commands/Default/SerializableValue.cs.meta
deleted file mode 100644
index 347a4b23..00000000
--- a/Core/Game/Player/Commands/Default/SerializableValue.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 5265bb710cedd48c5bacf337afd1f62d
-timeCreated: 1451622656
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Game/Player/Commands/ICommandData.cs b/Core/Game/Player/Commands/ICommandData.cs
deleted file mode 100644
index 56a698f8..00000000
--- a/Core/Game/Player/Commands/ICommandData.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using UnityEngine;
-using System.Collections;
-
-namespace Lockstep
-{
-    /// <summary>
-    /// Interface for data that gets registered for Commands. Note that Command data must createable via System.Activator.CreateInstance (Type)
-    /// </summary>
-    public interface ICommandData
-    {
-        /// <summary>
-        /// Function for custom writing of the data of this object.
-        /// </summary>
-        /// <param name="writer">Writer.</param>
-        void Write(Lockstep.Writer writer);
-        /// <summary>
-        /// Function for reading the custom data. After reading, this object should have the same values as the object that wrote the data.
-        /// </summary>
-        /// <param name="reader">Reader.</param>
-        void Read (Reader reader);
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/Commands/ICommandData.cs.meta b/Core/Game/Player/Commands/ICommandData.cs.meta
deleted file mode 100644
index a9dcb2cc..00000000
--- a/Core/Game/Player/Commands/ICommandData.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 319970e2b860849cbbb8a8ea0847c45e
-timeCreated: 1451617375
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Game/Player/RTSInterfacing.cs b/Core/Game/Player/Interfacing.cs
similarity index 89%
rename from Core/Game/Player/RTSInterfacing.cs
rename to Core/Game/Player/Interfacing.cs
index 1ea4dcd6..de590cd5 100644
--- a/Core/Game/Player/RTSInterfacing.cs
+++ b/Core/Game/Player/Interfacing.cs
@@ -4,7 +4,7 @@
 
 namespace Lockstep
 {
-	public static class RTSInterfacing
+	public static class Interfacing
 	{
 		public static Camera mainCamera { get; private set; }
 
@@ -117,15 +117,13 @@ public static Vector3 GetWorldPos3 (Vector2 screenPos)
 
 		public static void ActivateMarkerOnMouse (MarkerType markerType)
 		{
-            #if false
-            if (CachedDidHit) {
-                PlayerManager.OrderMarker.PlayOneShot (CachedHit.point, CachedHit.normal, markerType);
-                return;
-            }
-            Vector3 hitPoint = CachedRay.origin - CachedRay.direction * (CachedRay.origin.y / CachedRay .direction.y);
-                     if (PlayerManager.OrderMarker != null)
-            PlayerManager.OrderMarker.PlayOneShot (hitPoint, Vector3.up, markerType);
-            #endif
+			if (CachedDidHit) {
+				PlayerManager.OrderMarker.PlayOneShot (CachedHit.point, CachedHit.normal, markerType);
+				return;
+			}
+			Vector3 hitPoint = CachedRay.origin - CachedRay.direction * (CachedRay.origin.y / CachedRay .direction.y);
+            if (PlayerManager.OrderMarker != null)
+			PlayerManager.OrderMarker.PlayOneShot (hitPoint, Vector3.up, markerType);
 		}
 
 		private static Vector3 checkDir;
diff --git a/Core/Game/Player/RTSInterfacing.cs.meta b/Core/Game/Player/Interfacing.cs.meta
similarity index 100%
rename from Core/Game/Player/RTSInterfacing.cs.meta
rename to Core/Game/Player/Interfacing.cs.meta
diff --git a/Core/Game/Player/InterfacingHelper.cs b/Core/Game/Player/InterfacingHelper.cs
deleted file mode 100644
index 4ea06c8f..00000000
--- a/Core/Game/Player/InterfacingHelper.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using UnityEngine;
-using System.Collections;
-
-namespace Lockstep
-{
-    public abstract class InterfacingHelper
-    {
-        public void Initialize()
-        {
-            this.OnInitialize();
-        }
-
-        protected virtual void OnInitialize()
-        {
-
-        }
-
-        public void LateInitialize()
-        {
-            this.OnLateInitialize();
-        }
-
-        protected virtual void OnLateInitialize()
-        {
-
-        }
-
-        public void Simulate()
-        {
-            this.OnSimulate();   
-        }
-
-        protected virtual void OnSimulate()
-        {
-
-        }
-
-        public void Visualize()
-        {
-            this.OnVisualize();
-        }
-
-        protected virtual void OnVisualize()
-        {
-        }
-
-        public void Deactivate()
-        {
-            this.OnDeactivate();
-        }
-
-        protected virtual void OnDeactivate()
-        {
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Game/Player/InterfacingHelper.cs.meta b/Core/Game/Player/InterfacingHelper.cs.meta
deleted file mode 100644
index 3a4f05d0..00000000
--- a/Core/Game/Player/InterfacingHelper.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 2237aefeb81354479a7c35a4692b1dca
-timeCreated: 1451423936
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Game/Player/OrderMarker.cs b/Core/Game/Player/Marker.cs
similarity index 96%
rename from Core/Game/Player/OrderMarker.cs
rename to Core/Game/Player/Marker.cs
index 0b050fda..ad61a076 100644
--- a/Core/Game/Player/OrderMarker.cs
+++ b/Core/Game/Player/Marker.cs
@@ -1,7 +1,7 @@
 using UnityEngine;
 using System.Collections;
 using Lockstep;
-public class OrderMarker : MonoBehaviour {
+public class Marker : MonoBehaviour {
 	public Animation animation;
 	public Renderer renderer;
 	private Material material;
diff --git a/Core/Game/Player/OrderMarker.cs.meta b/Core/Game/Player/Marker.cs.meta
similarity index 100%
rename from Core/Game/Player/OrderMarker.cs.meta
rename to Core/Game/Player/Marker.cs.meta
diff --git a/Core/Game/Player/PlayerManager.cs b/Core/Game/Player/PlayerManager.cs
index 4f36458d..9442eb02 100644
--- a/Core/Game/Player/PlayerManager.cs
+++ b/Core/Game/Player/PlayerManager.cs
@@ -2,21 +2,53 @@
 using UnityEngine;
 
 namespace Lockstep {
-	public static class PlayerManager {
-
+	public class PlayerManager : MonoBehaviour {
+		[SerializeField]
+		private GUIStyle selectionBoxStyle = new GUIStyle();
+		[SerializeField]
+		private GameObject _orderMarker;
+		public static Marker OrderMarker {get; private set;}
+		
+		private static PlayerManager instance;
+		
+		public static SelectionSetting selectionSetting {get; private set;}
 		public static readonly FastBucket<AgentController> AgentControllers = new FastBucket<AgentController>();
 		public static AgentController MainController {get; private set;}
+		public static bool IsInterfacing {
+			get {
+				return InterfaceManager.IsGathering;
+			}
+		}
 
-        public static void Initialize() {
+		void Awake () {
+            instance = this;
+        }
+
+		
+		public static void Initialize(SelectionSetting selSetting = SelectionSetting.PC_RTS) {
 			AgentControllers.FastClear();
+			selectionSetting = selSetting;
 
-        }
+			OrderMarker =
+                instance._orderMarker != null ? GameObject.Instantiate (instance._orderMarker).GetComponent<Marker> ():
+                GameObject.CreatePrimitive(PrimitiveType.Cube).AddComponent<Marker> ();
+
+			InterfaceManager.Initialize ();
+		}
 		
 		public static void Simulate() {}
 		
 		public static void Visualize() {
+			switch (selectionSetting) {
+			case SelectionSetting.PC_RTS:
+				SelectionManager.Update();
+				CommandCard.Visualize ();
+				InterfaceManager.Visualize ();
+				break;
+			case SelectionSetting.Mobile:
 
-
+				break;
+			}
 		}
 		
 		public static int AgentControllerCount {
@@ -28,7 +60,7 @@ public static AgentController GetAgentController(int index) {
 		}
 		
         public static AgentController CreateController () {
-            AgentController ac = AgentController.Create();
+            AgentController ac = new AgentController();
             return ac;
         }
 
@@ -72,27 +104,35 @@ public static AllegianceType GetAllegiance (LSAgent agent)
 
 		public static void SendCommand (Command com)
 		{
-            com.Add<Selection>( new Selection ());
+			com.Select = new Selection ();
 			for (int i = 0; i < AgentControllers.Count; i++)
 			{
 				AgentController cont = AgentControllers[i];
 				if (cont.SelectedAgents.Count > 0)
 				{
-                    com.ControllerID = cont.ControllerID;
-
 					if (cont.SelectionChanged)
 					{
-                        com.SetData<Selection>( new Selection(cont.SelectedAgents));
-                        cont.SelectionChanged = false;
-
+						com.Select = new Selection(cont.SelectedAgents);
+						cont.SelectionChanged = false;
 					}
 					else {
-                        com.ClearData<Selection> ();
+						com.HasSelect = false;
 					}
-                    CommandManager.SendCommand (com);
+					com.ControllerID = cont.ControllerID;
+					com.Select.Serialize (AgentControllers[i].SelectedAgents);
+					CommandManager.SendCommand (com);
 				}
 			}
 		}
-
+		
+		private void OnGUI() {
+			switch (selectionSetting) {
+			case SelectionSetting.PC_RTS:
+				SelectionManager.DrawBox(selectionBoxStyle);
+				break;
+			case SelectionSetting.Mobile:
+				break;
+			}
+		}
 	}
 }
\ No newline at end of file
diff --git a/Core/Game/Player/SelectionManager.cs b/Core/Game/Player/SelectionManager.cs
index d2a8eda7..59fb673e 100644
--- a/Core/Game/Player/SelectionManager.cs
+++ b/Core/Game/Player/SelectionManager.cs
@@ -42,7 +42,7 @@ public static void Update ()
 		{
 
 			MousePosition = Input.mousePosition;
-			MouseWorldPosition = RTSInterfacing.GetWorldPos (MousePosition);
+			MouseWorldPosition = Interfacing.GetWorldPos (MousePosition);
 			CanClearSelection = !Input.GetKey (KeyCode.LeftShift);
 			GetMousedAgent ();
 
@@ -78,10 +78,10 @@ public static void Update ()
 						RaycastTopRight.y = BoxStart.y;
 					}
 
-					Box_TopLeft = RTSInterfacing.GetWorldPos (RaycastTopLeft);
-					Box_TopRight = RTSInterfacing.GetWorldPos (RaycastTopRight);
-					Box_BottomLeft = RTSInterfacing.GetWorldPos (RaycastBotLeft);
-					Box_BottomRight = RTSInterfacing.GetWorldPos (RaycastBotRight);
+					Box_TopLeft = Interfacing.GetWorldPos (RaycastTopLeft);
+					Box_TopRight = Interfacing.GetWorldPos (RaycastTopRight);
+					Box_BottomLeft = Interfacing.GetWorldPos (RaycastBotLeft);
+					Box_BottomRight = Interfacing.GetWorldPos (RaycastBotRight);
 				}
 
 				ClearBox ();
@@ -142,7 +142,7 @@ public static void Update ()
 					if (CanClearSelection) {
 						ClearSelection ();
 					}
-                    if (RTSInterfacingHelper.IsGathering == false) {
+					if (PlayerManager.IsInterfacing == false) {
 						SelectBoxedAgents ();
 					}
 
@@ -151,7 +151,7 @@ public static void Update ()
 
 			} else {
 
-                if (RTSInterfacingHelper.IsGathering == false && Input.GetMouseButtonDown (0)) {
+				if (PlayerManager.IsInterfacing == false && InputManager.GetInformationDown ()) {
 					CheckBoxDistance = true;
 					Boxing = true;
 					BoxingTime = 0f;
@@ -256,7 +256,7 @@ public static float DotEdge ()
 
 		private static void GetMousedAgent ()
 		{            
-			MouseOver (RTSInterfacing.GetScreenAgent (Input.mousePosition, (agent) => {
+			MouseOver (Interfacing.GetScreenAgent (Input.mousePosition, (agent) => {
 				return agent.CanSelect && PlayerManager.ContainsController (agent.Controller);}));
 
 		}
diff --git a/Core/Game/Player/UI/EnvironmentUIController.cs b/Core/Game/Player/UI/EnvironmentUIController.cs
new file mode 100644
index 00000000..ed5eace7
--- /dev/null
+++ b/Core/Game/Player/UI/EnvironmentUIController.cs
@@ -0,0 +1,25 @@
+using UnityEngine;
+using System.Collections;
+using Lockstep.UI;
+namespace Lockstep {
+	public class EnvironmentUIController : MonoBehaviour {
+		[SerializeField]
+		private CommandCard _comCard;
+		public CommandCard ComCard {get {return _comCard;}}
+		[SerializeField]
+		private BuildMenu _buildingMenu;
+		public BuildMenu BuildingMenu {get {return _buildingMenu;}}
+		void Awake () {
+			gameObject.SetActive (false); //Prevents multiple MenuUIs from being active
+		}
+		public void Setup () {
+			gameObject.SetActive (true);
+			ComCard.Setup ();
+			_buildingMenu.Setup ();
+		}
+		public void Initialize () {
+			_buildingMenu.Initialize ();
+
+		}
+	}
+}
\ No newline at end of file
diff --git a/Core/Game/Player/UI/EnvironmentUIController.cs.meta b/Core/Game/Player/UI/EnvironmentUIController.cs.meta
new file mode 100644
index 00000000..b02c3d95
--- /dev/null
+++ b/Core/Game/Player/UI/EnvironmentUIController.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e2bb378f5f78b4dee95ef7464621df0c
+timeCreated: 1441307827
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Game/Player/UI/StatsBar.cs b/Core/Game/Player/UI/StatsBar.cs
index bdb00bd4..be09abe3 100644
--- a/Core/Game/Player/UI/StatsBar.cs
+++ b/Core/Game/Player/UI/StatsBar.cs
@@ -47,7 +47,7 @@ public void Initialize ()
 
 		public void Visualize ()
 		{
-            if (RTSInterfacingHelper.GUIManager.CameraChanged && TrackedAgent.IsVisible) {
+			if (InterfaceManager.GUIManager.CameraChanged && TrackedAgent.IsVisible) {
 				this.UpdatePos ();
 				this.UpdateScale ();
 			} else if (TrackedAgent.VisualPositionChanged) {
@@ -55,7 +55,7 @@ public void Visualize ()
 			}
 		}
 
-        static GUIManager GUIManager {get {return RTSInterfacingHelper.GUIManager;}}
+        static GUIManager GUIManager {get {return InterfaceManager.GUIManager;}}
 		static Camera MainCam { get { return GUIManager.MainCam; } }
 
 		static Vector3 screenPos;
diff --git a/Core/Game/Player/Utility/Selection.cs b/Core/Game/Player/Utility/Selection.cs
index 0960a562..ea85883e 100644
--- a/Core/Game/Player/Utility/Selection.cs
+++ b/Core/Game/Player/Utility/Selection.cs
@@ -1,13 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Collections;
-using UnityEngine;
-using Stopwatch = System.Diagnostics.Stopwatch;
 namespace Lockstep {
-    public class Selection : ICommandData{
-        private static readonly FastList<byte> bufferBites = new FastList<byte>();
-        static readonly FastList<LSAgent> bufferAgents = new FastList<LSAgent>();
-
+    public class Selection {
         private static int bigIndex, smallIndex;
         private static ulong castedBigIndex;
         private static byte cullGroup;
@@ -15,60 +9,28 @@ public class Selection : ICommandData{
         private static int curIndex;
 
 		public FastList<ushort> selectedAgentLocalIDs = new FastList<ushort>();
-        private  BitArray Header;
-        private readonly FastList<byte> Data = new FastList<byte>();
-       
+        public ulong Header;
+        public readonly byte[] Data = new byte[64];
+
         private AgentController leAgentController;
 
         public Selection() {}
 
+		static readonly FastList<LSAgent> bufferAgents = new FastList<LSAgent>();
 
         public Selection(FastEnumerable<LSAgent> selectedAgents) {
-            
             Serialize(selectedAgents);
         }
 
-        public byte[] GetBytes () {
-
-
-            bufferBites.FastClear();
-            //Serialize header
-            int headerLength = Header.Length;
-            int headerArraySize = (headerLength - 1) / 8 + 1;
-
-            bufferBites.Add((byte)headerArraySize);
-            byte[] headerBytes = new byte[headerArraySize];
-
-            Header.CopyTo(headerBytes, 0);
-
-            bufferBites.AddRange(headerBytes);
-
-            //Serializing the good stuff
-            for (int i = 0; i < Header.Length; i++) {
-                if (Header.Get(i)) {
-                    bufferBites.Add(Data[i]);
-                }
-            }
-            return bufferBites.ToArray();
-        }
-
         public void Serialize(FastEnumerable<LSAgent> selectedAgents) {
-
-            Data.FastClear();
-            selectedAgentLocalIDs.FastClear ();
+            Array.Clear(Data, 0, 64);
+            Header = 0;
+			selectedAgentLocalIDs.FastClear ();
 			bufferAgents.FastClear ();
 			selectedAgents.Enumerate (bufferAgents);
-            ushort highestID = 0;
-            for (int i = 0; i < bufferAgents.Count; i++) {
-                ushort id = bufferAgents[i].LocalID;
-                if (id > highestID) highestID = id;
-            }
-            int headerLength = (highestID + 1 - 1) / 8 + 1;
-            Header = new BitArray(headerLength, false);
 			for (int i = 0; i < bufferAgents.Count; i++) {
                 SerializeAgent(bufferAgents[i]);
             }
-
         }
 
         private void SerializeAgent(LSAgent agent) {
@@ -79,29 +41,24 @@ private void SerializeAgent(LSAgent agent) {
             bigIndex = (agent.LocalID / 8);
             smallIndex = (agent.LocalID % 8);
 
-            Header.Set(bigIndex, true);
-            Data.EnsureCapacity(bigIndex + 1);
+            Header |= (ulong)1 << bigIndex;
             Data[bigIndex] |= (byte)(1 << smallIndex);
 
 			selectedAgentLocalIDs.Add (agent.LocalID);
         }
 
         public int Reconstruct(byte[] source, int startIndex) {
-
             curIndex = startIndex;
+            Header = BitConverter.ToUInt64(source, curIndex);
+            curIndex += 8;
 
-            byte headerArraySize = source[curIndex++];
-
-            byte[] headerBytes = new byte[headerArraySize];
-            Array.Copy(source,curIndex,headerBytes,0,headerArraySize);
-            curIndex += headerArraySize;
-            Header = new BitArray(headerBytes);
             selectedAgentLocalIDs.FastClear();
-            for (int i = 0; i < Header.Length; i++) {
-                if (Header.Get(i)) {
+            
 
+			for (int i = 0; i < 64; i++) {
+                castedBigIndex = (ulong)1 << i;
+                if ((Header & castedBigIndex) == castedBigIndex) {
                     cullGroup = source[curIndex++];
-
 					for (int j = 0; j < 8; j++) {
                         castedSmallIndex = (byte)(1 << j);
                         if ((cullGroup & (castedSmallIndex)) == castedSmallIndex) {
@@ -110,18 +67,9 @@ public int Reconstruct(byte[] source, int startIndex) {
                     }
                 }
             }
-
             return curIndex - startIndex;
         }
 
-        public void Write (Writer writer) {
-            writer.Write(this.GetBytes());
-        }
-        public void Read (Reader reader) {
-            int move = this.Reconstruct(reader.Source, reader.Position);
-            reader.MovePosition(move);
-        }
-
         public override string ToString() {
             string s = "Selected Agents: ";
             if (selectedAgentLocalIDs .IsNotNull ()) {
diff --git a/Core/Game/Player/Utility/Selector.cs b/Core/Game/Player/Utility/Selector.cs
index 9de55bb4..9b95b982 100644
--- a/Core/Game/Player/Utility/Selector.cs
+++ b/Core/Game/Player/Utility/Selector.cs
@@ -4,6 +4,13 @@ public static class Selector {
 		private static LSAgent _mainAgent;
 		public static LSAgent MainSelectedAgent {get {return _mainAgent;}
 			private set{
+				if (value .IsNotNull ())
+				{
+					CommandCard.Inject (value.Interfacers);
+				}
+				else {
+					CommandCard.Reset ();
+				}
 				_mainAgent = value;
 			}
 		}
diff --git a/Core/Game/Projectiles/LSProjectile.cs b/Core/Game/Projectiles/LSProjectile.cs
index af075f32..87882b26 100644
--- a/Core/Game/Projectiles/LSProjectile.cs
+++ b/Core/Game/Projectiles/LSProjectile.cs
@@ -432,7 +432,7 @@ public void Initialize (int id, LSAgent source, LSAgent target)
 			this.AliveTime = 0;
 			if (Source.Scanner .IsNotNull ()) {
 				this.Position = Source.Scanner.ProjectileOffset;
-                this.Position.RotateInverse (source.Body._rotation.x,source.Body._rotation.y);
+				this.Position.RotateInverse (source.Body.Rotation.x,source.Body.Rotation.y);
 				this.Position += this.Source.Body._position;
 				this.CurrentHeight = this.Source.CachedTransform.position.y + source.Scanner.ProjectileHeightOffset;
 			}
@@ -514,7 +514,7 @@ private void OnHit ()
 				ApplyArea (this.TargetPosition, this.Radius, this.DealDamageAction);
 				break;
 			case DamageType.Cone:
-                    ApplyCone (this.Position, this.Source.Body._rotation, this.Radius, this.Angle, DealDamageAction, this.TargetPlatform);
+				ApplyCone (this.Position, this.Source.Body.Rotation, this.Radius, this.Angle, DealDamageAction, this.TargetPlatform);
 				break;
 			}
 		}
diff --git a/Core/Simulation/.DS_Store b/Core/Simulation/.DS_Store
deleted file mode 100644
index ab09fcf1..00000000
Binary files a/Core/Simulation/.DS_Store and /dev/null differ
diff --git a/Core/Simulation/Grid/Core/GridManager.cs b/Core/Simulation/Grid/Core/GridManager.cs
index 3e9e34a7..7cd10494 100644
--- a/Core/Simulation/Grid/Core/GridManager.cs
+++ b/Core/Simulation/Grid/Core/GridManager.cs
@@ -100,7 +100,6 @@ private static void Generate ()
             for (int i = ScanWidth - 1; i >= 0; i--) {
                 for (int j = ScanHeight - 1; j >= 0; j--) {
                     ScanNode node = CachedScanNodes.Count > 0 ? CachedScanNodes.Pop() : new ScanNode ();
-                    node.Setup(i,j);
                     ScanGrid [GetScanIndex (i, j)] = node;
 				}
 			}
diff --git a/Core/Simulation/Grid/Utility/Tools/Blocker/Blocker.cs b/Core/Simulation/Grid/Utility/Tools/Blocker/Blocker.cs
index d2fab5f6..9a9343d7 100644
--- a/Core/Simulation/Grid/Utility/Tools/Blocker/Blocker.cs
+++ b/Core/Simulation/Grid/Utility/Tools/Blocker/Blocker.cs
@@ -2,14 +2,14 @@
 using System.Collections;
 using Lockstep;
 
-//Blocker for static environment pieces in a scene.
 [RequireComponent (typeof (LSBody))]
 public class Blocker : EnvironmentObject
 {
     static readonly FastList<Vector2d> bufferCoordinates = new FastList<Vector2d>();
 
+
     [SerializeField]
-    private bool _blockPathfinding = true;
+    private bool _blockPathfinding;
     public bool BlockPathfinding {get {return _blockPathfinding;}}
 
 
diff --git a/Core/Simulation/Math/Coordinate.cs b/Core/Simulation/Math/Coordinate.cs
index b41812dc..13f7dcdd 100644
--- a/Core/Simulation/Math/Coordinate.cs
+++ b/Core/Simulation/Math/Coordinate.cs
@@ -1,42 +1,25 @@
 using UnityEngine;
 using System.Collections;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+public struct Coordinate {
+	public int x;
+	public int y;
+	public Coordinate (int X, int Y)
+	{
+		x = X;
+		y = Y;
+	}
+	public override string ToString ()
+	{
+		return "(" + x.ToString () + ", " + y.ToString() + ")";
+	}
 
-namespace Lockstep
-{
-    #if UNITY_EDITOR
-    using UnityEditor;
-    #endif
-    public struct Coordinate : ICommandData
-    {
-        public int x;
-        public int y;
-
-        public Coordinate(int X, int Y)
-        {
-            x = X;
-            y = Y;
-        }
-
-        public override string ToString()
-        {
-            return "(" + x.ToString() + ", " + y.ToString() + ")";
-        }
-
-        public void Write (Writer writer) {
-            writer.Write (x);
-            writer.Write (y);
-        }
-        public void Read (Reader reader) {
-            this.x = reader.ReadInt ();
-            this.y = reader.ReadInt();
-        }
-
-        #if UNITY_EDITOR
-        public void OnSerializeGUI()
-        {
-            x = EditorGUILayout.IntField("X", x);
-            y = EditorGUILayout.IntField("Y", y);
-        }
-        #endif
-    }
-}
\ No newline at end of file
+#if UNITY_EDITOR
+	public void OnSerializeGUI () {
+		x = EditorGUILayout.IntField ("X", x);
+		y = EditorGUILayout.IntField ("Y", y);
+	}
+#endif
+}
diff --git a/Core/Simulation/Math/FixedMath.cs b/Core/Simulation/Math/FixedMath.cs
index f00454e5..4b9d41cc 100644
--- a/Core/Simulation/Math/FixedMath.cs
+++ b/Core/Simulation/Math/FixedMath.cs
@@ -180,7 +180,7 @@ public static bool AbsMoreThan (this long f1, long f2) {
 		/// <param name="f1">F1.</param>
 		public static long Truncate (long f1)
 		{
-			return ((f1) >> SHIFT_AMOUNT) << SHIFT_AMOUNT;
+			return ((f1 + Half) >> SHIFT_AMOUNT) << SHIFT_AMOUNT;
 		}
 		/// <summary>
 		/// Round the specified fixed point number.
@@ -190,7 +190,10 @@ public static long Round (long f1)
 		{
 			return ((f1 + FixedMath.Half - 1) >> SHIFT_AMOUNT) << SHIFT_AMOUNT;
 		}
-
+		public static long RoundToInteger (long f1)
+		{
+			return ((f1 + FixedMath.Half - 1) >> SHIFT_AMOUNT) << SHIFT_AMOUNT;
+		}
 		/// <summary>
 		/// Ceil the specified fixed point number.
 		/// </summary>
@@ -256,10 +259,6 @@ public static float ToFloat (this long f1)
 		{
 			return (float)(f1 / OneD);
 		}
-
-        public static float ToPreciseFloat (this long f1) {
-            return (float)ToDouble (f1);
-        }
 		/// <summary>
 		/// Converts to string.
 		/// </summary>
diff --git a/Core/Simulation/Math/Vector2d.cs b/Core/Simulation/Math/Vector2d.cs
index 69d038b1..5521607e 100644
--- a/Core/Simulation/Math/Vector2d.cs
+++ b/Core/Simulation/Math/Vector2d.cs
@@ -5,413 +5,336 @@
 
 namespace Lockstep
 {
-    [Serializable]
-    public struct Vector2d : ICommandData
-    {
-        [FixedNumber]
-        public long x;
-        [FixedNumber]
-        public long y;
-
-
-        #region Constructors
-
-        public Vector2d(long xFixed, long yFixed)
-        {
-            this.x = xFixed;
-            this.y = yFixed;
-        }
-
-        public Vector2d(int xInt, int yInt)
-        {
-            this.x = xInt << FixedMath.SHIFT_AMOUNT;
-            this.y = yInt << FixedMath.SHIFT_AMOUNT;
-        }
-
-        public Vector2d(Vector2 vec2)
-        {
-            this.x = FixedMath.Create(vec2.x);
-            this.y = FixedMath.Create(vec2.y);
-        }
-
-        public Vector2d(float xFloat, float yFloat)
-        {
-            this.x = FixedMath.Create(xFloat);
-            this.y = FixedMath.Create(yFloat);
-        }
-
-        public Vector2d(double xDoub, double yDoub)
-        {
-            this.x = FixedMath.Create(xDoub);
-            this.y = FixedMath.Create(yDoub);
-        }
-
-        public Vector2d(Vector3 vec)
-        {
-            this.x = FixedMath.Create(vec.x);
-            this.y = FixedMath.Create(vec.z);
-        }
-
-        #endregion
-
-
-        #region Local Math
-
-        public void Subtract(ref Vector2d other)
-        {
-            this.x -= other.x;
-            this.y -= other.y;
-        }
-
-        public void Add(ref Vector2d other)
-        {
-            this.x += other.x;
-            this.y += other.y;
-        }
-
-
-        /// <summary>
-        /// This vector's square magnitude.
-        /// </summary>
-        /// <returns>The magnitude.</returns>
-        public long SqrMagnitude()
-        {
-            return (this.x * this.x + this.y * this.y) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        /// <summary>
-        /// This vector's magnitude.
-        /// </summary>
-        public long Magnitude()
-        {
-            temp1 = (this.x * this.x + this.y * this.y);
-            if (temp1 == 0)
-                return 0;
-            temp1 >>= FixedMath.SHIFT_AMOUNT;
-            return FixedMath.Sqrt(temp1);
-        }
-
-        public long FastMagnitude()
-        {
-            return this.x * this.x + this.y * this.y;
-        }
-
-        /// <summary>
-        /// Normalize this vector.
-        /// </summary>
-        public void Normalize()
-        {
-            tempMag = this.Magnitude();
-            if (tempMag == 0)
-            {
-                return;
-            } else if (tempMag == FixedMath.One)
-            {
-                return;
-            }
-            this.x = (this.x << FixedMath.SHIFT_AMOUNT) / tempMag;
-            this.y = (this.y << FixedMath.SHIFT_AMOUNT) / tempMag;
-        }
-
-        public void Normalize(out long mag)
-        {
-            mag = this.Magnitude();
-            if (mag == 0)
-            {
-                return;
-            } else if (mag == FixedMath.One)
-            {
-                return;
-            }
-            this.x = (this.x << FixedMath.SHIFT_AMOUNT) / mag;
-            this.y = (this.y << FixedMath.SHIFT_AMOUNT) / mag;
-        }
-
-        /// <summary>
-        /// Lerp this vector to target by amount.
-        /// </summary>
-        /// <param name="target">target.</param>
-        /// <param name="amount">amount.</param>
-        public void Lerp(long targetx, long targety, long amount)
-        {
-            if (amount >= FixedMath.One)
-            {
-                this.x = targetx;
-                this.y = targety;
-                return;
-            } else if (amount <= 0)
-            {
-                return;
-            }
-            this.x = (targetx * amount + this.x * (FixedMath.One - amount)) >> FixedMath.SHIFT_AMOUNT;
-            this.y = (targety * amount + this.y * (FixedMath.One - amount)) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        public void Rotate(long cos, long sin)
-        {
-            temp1 = (this.x * cos + this.y * sin) >> FixedMath.SHIFT_AMOUNT;
-            this.y = (this.x * -sin + this.y * cos) >> FixedMath.SHIFT_AMOUNT;
-            this.x = temp1;
-        }
-        public Vector2d Rotated (long cos, long sin) {
-            Vector2d vec = this;
-            vec.Rotate(cos,sin);
-            return vec;
-        }
-        public void RotateInverse(long cos, long sin)
-        {
-            Rotate(cos, -sin);
-        }
-
-        public void RotateRight()
-        {
-            temp1 = this.x;
-            this.x = this.y;
-            this.y = -temp1;
-        }
-
-        static Vector2d retVec = Vector2d.zero;
-
-        public Vector2d rotatedRight
-        {
-            get
-            {
-                retVec.x = y;
-                retVec.y = -x;
-                return retVec;
-            }
-        }
-
-        public Vector2d rotatedLeft
-        {
-            get
-            {
-                retVec.x = -y;
-                retVec.y = x;
-                return retVec;
-            }
-        }
-
-        public void Reflect(long axisX, long axisY)
-        {
-            temp3 = this.Dot(axisX, axisY);
-            temp1 = (axisX * temp3) >> FixedMath.SHIFT_AMOUNT;
-            temp2 = (axisY * temp3) >> FixedMath.SHIFT_AMOUNT;
-            this.x = temp1 + temp1 - this.x;
-            this.y = temp2 + temp2 - this.y;
-        }
-
-        public void Reflect(long axisX, long axisY, long projection)
-        {
-            temp1 = (axisX * projection) >> FixedMath.SHIFT_AMOUNT;
-            temp2 = (axisY * projection) >> FixedMath.SHIFT_AMOUNT;
-            this.x = temp1 + temp1 - this.x;
-            this.y = temp2 + temp2 - this.y;
-        }
-
-        public long Dot(long otherX, long otherY)
-        {
-            return (this.x * otherX + this.y * otherY) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        public long Cross(long otherX, long otherY)
-        {
-            return (this.x * otherY - this.y * otherX) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        static long temp1;
-        static long temp2;
-        static long temp3;
-        static long tempMag;
-
-        public long Distance(long otherX, long otherY)
-        {
-            temp1 = this.x - otherX;
-            temp1 *= temp1;
-            temp2 = this.y - otherY;
-            temp2 *= temp2;
-            return (FixedMath.Sqrt((temp1 + temp2) >> FixedMath.SHIFT_AMOUNT));
-        }
-
-        public long Distance(Vector2d other)
-        {
-            return Distance(other.x, other.y);
-        }
-
-        public long SqrDistance(long otherX, long otherY)
-        {
-
-            temp1 = this.x - otherX;
-            temp1 *= temp1;
-            temp2 = this.y - otherY;
-            temp2 *= temp2;
-            return ((temp1 + temp2) >> FixedMath.SHIFT_AMOUNT);
-        }
-
-        /// <summary>
-        /// Returns a value that is greater if the distance is greater.
-        /// </summary>
-        /// <returns>The FastDistance.</returns>
-        public long FastDistance(long otherX, long otherY)
-        {
-            temp1 = this.x - otherX;
-            temp1 *= temp1;
-            temp2 = this.y - otherY;
-            temp2 *= temp2;
-            return (temp1 + temp2);
-        }
-
-        public bool NotZero()
-        {
-            return x.MoreThanEpsilon() || y.MoreThanEpsilon();
-        }
-
-        #endregion
-
-        #region Static Math
-
-        public static readonly Vector2d up = new Vector2d(0, 1);
-        public static readonly Vector2d right = new Vector2d(1, 0);
-        public static readonly Vector2d down = new Vector2d(0, -1);
-        public static readonly Vector2d left = new Vector2d(-1, 0);
-        public static readonly Vector2d one = new Vector2d(1, 1);
-        public static readonly Vector2d negative = new Vector2d(-1, -1);
-        public static readonly Vector2d zero = new Vector2d(0, 0);
-
-        public static long Dot(long v1x, long v1y, long v2x, long v2y)
-        {
-            return (v1x * v2x + v1y * v2y) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        public static long Cross(long v1x, long v1y, long v2x, long v2y)
-        {
-            return (v1x * v2y - v1y * v2x) >> FixedMath.SHIFT_AMOUNT;
-        }
-
-        /// <summary>
-        /// Note: Not deterministic. Use only for serialization and sending in Commands.
-        /// </summary>
-        /// <returns>The from angle.</returns>
-        /// <param name="angle">Angle.</param>
-        public static Vector2d CreateFromAngle(float angle)
-        {
-            return new Vector2d(Math.Sin(angle), Math.Cos(angle));
-        }
-
-        #endregion
-
-        #region Convert
-
-        public override string ToString()
-        {
-            return (
-                "(" +
-                Math.Round(FixedMath.ToDouble(this.x), 2, MidpointRounding.AwayFromZero).ToString() +
-                ", " +
-                Math.Round(FixedMath.ToDouble(this.y), 2, MidpointRounding.AwayFromZero) +
-                ")"
-            );
-        }
-
-        public Vector2 ToVector2()
-        {
-            return new Vector2(
-                (float)FixedMath.ToDouble(this.x),
-                (float)FixedMath.ToDouble(this.y)
-            );
-        }
-
-        public Vector3 ToVector3(float y = 0f)
-        {
-            return new Vector3((float)FixedMath.ToDouble(this.x), y, (float)FixedMath.ToDouble(this.y));
-        }
+	[Serializable]
+	public struct Vector2d
+	{
+		[FixedNumber]
+		public long x;
+		[FixedNumber]
+		public long y;
+
+
+	#region Constructors
+		public Vector2d (long xFixed, long yFixed)
+		{
+			this.x = xFixed;
+			this.y = yFixed;
+		}
+
+		public Vector2d (int xInt, int yInt)
+		{
+			this.x = xInt << FixedMath.SHIFT_AMOUNT;
+			this.y = yInt << FixedMath.SHIFT_AMOUNT;
+		}
+
+		public Vector2d (Vector2 vec2)
+		{
+			this.x = FixedMath.Create (vec2.x);
+			this.y = FixedMath.Create (vec2.y);
+		}
+		public Vector2d (float xFloat, float yFloat)
+		{
+			this.x = FixedMath.Create (xFloat);
+			this.y = FixedMath.Create (yFloat);
+		}
+		public Vector2d (Vector3 vec)
+		{
+			this.x = FixedMath.Create (vec.x);
+			this.y = FixedMath.Create (vec.z);
+		}
+	#endregion
+
+
+	#region Local Math
+		public void Subtract (ref Vector2d other)
+		{
+			this.x -= other.x;
+			this.y -= other.y;
+		}
+		public void Add (ref Vector2d other)
+		{
+			this.x += other.x;
+			this.y += other.y;
+		}
+
+
+		/// <summary>
+		/// This vector's square magnitude.
+		/// </summary>
+		/// <returns>The magnitude.</returns>
+		public long SqrMagnitude ()
+		{
+			return (this.x * this.x + this.y * this.y) >> FixedMath.SHIFT_AMOUNT;
+		}
+		/// <summary>
+		/// This vector's magnitude.
+		/// </summary>
+		public long Magnitude ()
+		{
+			temp1 = (this.x * this.x + this.y * this.y);
+			if (temp1 == 0) return 0;
+			temp1 >>= FixedMath.SHIFT_AMOUNT;
+			return FixedMath.Sqrt (temp1);
+		}
+		public long FastMagnitude ()
+		{
+			return this.x * this.x + this.y * this.y;
+		}
+		/// <summary>
+		/// Normalize this vector.
+		/// </summary>
+		public void Normalize ()
+		{
+			tempMag = this.Magnitude ();
+			if (tempMag == 0)
+			{
+				return;
+			}
+			else if (tempMag == FixedMath.One)
+			{
+				return;
+			}
+			this.x = (this.x << FixedMath.SHIFT_AMOUNT) / tempMag;
+			this.y = (this.y << FixedMath.SHIFT_AMOUNT) / tempMag;
+		}
+		public void Normalize (out long mag)
+		{
+			mag = this.Magnitude ();
+			if (mag == 0)
+			{
+				return;
+			}
+			else if (mag == FixedMath.One)
+			{
+				return;
+			}
+			this.x = (this.x << FixedMath.SHIFT_AMOUNT) / mag;
+			this.y = (this.y << FixedMath.SHIFT_AMOUNT) / mag;
+		}
+		/// <summary>
+		/// Lerp this vector to target by amount.
+		/// </summary>
+		/// <param name="target">target.</param>
+		/// <param name="amount">amount.</param>
+		public void Lerp (long targetx, long targety, long amount)
+		{
+			if (amount >= FixedMath.One) {
+				this.x = targetx;
+				this.y = targety;
+				return;
+			} else if (amount <= 0) {
+				return;
+			}
+			this.x = (targetx * amount + this.x * (FixedMath.One - amount)) >> FixedMath.SHIFT_AMOUNT;
+			this.y = (targety * amount + this.y * (FixedMath.One - amount)) >> FixedMath.SHIFT_AMOUNT;
+		}
+
+		public void Rotate (long cos, long sin)
+		{
+			temp1 = (this.x * cos + this.y * sin) >> FixedMath.SHIFT_AMOUNT;
+			this.y = (this.x * -sin + this.y * cos) >> FixedMath.SHIFT_AMOUNT;
+			this.x = temp1;
+		}
+		public void RotateInverse (long cos, long sin)
+		{
+			Rotate (cos, -sin);
+		}
+		public void RotateRight ()
+		{
+			temp1 = this.x;
+			this.x = this.y;
+			this.y = -temp1;
+		}
+
+		static Vector2d retVec = Vector2d.zero;
+		public Vector2d rotatedRight
+		{
+			get {
+			retVec.x = y;
+			retVec.y = -x;
+			return retVec;
+			}
+		}
+		public Vector2d rotatedLeft {
+			get {
+				retVec.x = -y;
+				retVec.y = x;
+				return retVec;
+			}
+		}
+		public void Reflect (long axisX, long axisY)
+		{
+			temp3 = this.Dot (axisX, axisY);
+			temp1 = (axisX * temp3) >> FixedMath.SHIFT_AMOUNT;
+			temp2 = (axisY * temp3) >> FixedMath.SHIFT_AMOUNT;
+			this.x = temp1 + temp1 - this.x;
+			this.y = temp2 + temp2 - this.y;
+		}
+		public void Reflect (long axisX, long axisY, long projection)
+		{
+			temp1 = (axisX * projection) >> FixedMath.SHIFT_AMOUNT;
+			temp2 = (axisY * projection) >> FixedMath.SHIFT_AMOUNT;
+			this.x = temp1 + temp1 - this.x;
+			this.y = temp2 + temp2 - this.y;
+		}
+		public long Dot (long otherX, long otherY)
+		{
+			return (this.x * otherX + this.y * otherY) >> FixedMath.SHIFT_AMOUNT;
+		}
+		public long Cross (long otherX, long otherY)
+		{
+			return (this.x * otherY - this.y * otherX) >> FixedMath.SHIFT_AMOUNT;
+		}
+
+		static long temp1;
+		static long temp2;
+		static long temp3;
+		static long tempMag;
+		public long Distance (long otherX, long otherY)
+		{
+			temp1 = this.x - otherX;
+			temp1 *= temp1;
+			temp2 = this.y - otherY;
+			temp2 *= temp2;
+			return (FixedMath.Sqrt ((temp1 + temp2) >> FixedMath.SHIFT_AMOUNT));
+		}
+		public long Distance (Vector2d other)
+		{
+			return Distance (other.x,other.y);
+		}
+		public long SqrDistance (long otherX, long otherY)
+		{
+
+			temp1 = this.x - otherX;
+			temp1 *= temp1;
+			temp2 = this.y - otherY;
+			temp2 *= temp2;
+			return ((temp1 + temp2) >> FixedMath.SHIFT_AMOUNT);
+		}
+		/// <summary>
+		/// Returns a value that is greater if the distance is greater.
+		/// </summary>
+		/// <returns>The FastDistance.</returns>
+		public long FastDistance (long otherX, long otherY)
+		{
+			temp1 = this.x - otherX;
+			temp1 *= temp1;
+			temp2 = this.y - otherY;
+			temp2 *= temp2;
+			return (temp1 + temp2);
+		}
+		public bool NotZero ()
+		{
+			return x.MoreThanEpsilon () || y.MoreThanEpsilon ();
+		}
+	#endregion
+
+	#region Static Math
+		public static readonly Vector2d up = new Vector2d (0,1);
+		public static readonly Vector2d right = new Vector2d (1,0);
+		public static readonly Vector2d down = new Vector2d (0,-1);
+		public static readonly Vector2d left = new Vector2d (-1,0);
+		public static readonly Vector2d one = new Vector2d (1,1);
+		public static readonly Vector2d negative = new Vector2d (-1,-1);
+		public static readonly Vector2d zero = new Vector2d (0,0);
+		public static long Dot (long v1x, long v1y, long v2x, long v2y)
+		{
+			return (v1x * v2x + v1y * v2y) >> FixedMath.SHIFT_AMOUNT;
+		}
+		public static long Cross (long v1x, long v1y, long v2x, long v2y)
+		{
+			return (v1x * v2y - v1y * v2x) >> FixedMath.SHIFT_AMOUNT;
+		}
+	#endregion
+
+	#region Convert
+		public override string ToString ()
+		{
+			return (
+				"(" +
+				Math.Round (FixedMath.ToDouble (this.x), 2, MidpointRounding.AwayFromZero).ToString () +
+				", " +
+				Math.Round (FixedMath.ToDouble (this.y), 2, MidpointRounding.AwayFromZero) +
+				")"
+				);
+		}
+		public Vector2 ToVector2 ()
+		{
+			return new Vector2 (
+				(float)FixedMath.ToDouble (this.x),
+				(float)FixedMath.ToDouble (this.y)
+				);
+		}
+
+	    public Vector3 ToVector3(float y) {
+	        return new Vector3((float)FixedMath.ToDouble(this.x), y, (float)FixedMath.ToDouble(this.y));
+	    }
 
         public Vector3 ToScaledVector3(float y)
         {
-            return ToVector3(y);
+			return ToVector3(y);
             //return new Vector3((float)FixedMath.ToDouble(this.x) * LockstepManager.WorldScale, y, (float)FixedMath.ToDouble(this.y) * LockstepManager.WorldScale);
         }
 
-        #endregion
-
-        public override bool Equals(object obj)
-        {
-            if (obj is Vector2d)
-            {
-                return (Vector2d)obj == this;
-            }
-            return false;
-        }
-
-        #region Operators
-
-        public static Vector2d operator +(Vector2d v1, Vector2d v2)
-        {
-            return new Vector2d(v1.x + v2.x, v1.y + v2.y);
-        }
-
-        public static Vector2d operator -(Vector2d v1, Vector2d v2)
-        {
-            return new Vector2d(v1.x - v2.x, v1.y - v2.y);
-        }
-
-        public static Vector2d operator *(Vector2d v1, long mag)
-        {
-            return new Vector2d((v1.x * mag) >> FixedMath.SHIFT_AMOUNT, (v1.y * mag) >> FixedMath.SHIFT_AMOUNT);
-        }
-
-        public static Vector2d operator *(Vector2d v1, int mag)
-        {
-            return new Vector2d((v1.x * mag), (v1.y * mag));
-        }
-
-        public static Vector2d operator /(Vector2d v1, long div)
-        {
-            return new Vector2d(((v1.x << FixedMath.SHIFT_AMOUNT) / div), (v1.y << FixedMath.SHIFT_AMOUNT) / div);
-        }
-
-        public static Vector2d operator /(Vector2d v1, int div)
-        {
-            return new Vector2d((v1.x / div), v1.y / div);
-        }
-
-        public static Vector2d operator >>(Vector2d v1, int shift)
-        {
-            return new Vector2d(v1.x >> shift, v1.y >> shift);
-        }
-
-        public static bool operator ==(Vector2d v1, Vector2d v2)
-        {
-            return v1.x == v2.x && v1.y == v2.y;
-        }
-
-        public static bool operator !=(Vector2d v1, Vector2d v2)
-        {
-            return v1.x != v2.x || v1.y != v2.y;
-        }
-
-        #endregion
-
-        public long GetLongHashCode()
-        {
-            return x * 31 + y * 7;
-        }
-
-        public int GetStateHash()
-        {
-            return (int)(GetLongHashCode() % int.MaxValue);
-        }
-
-        public void Write(Writer writer)
-        {
-            writer.Write(this.x);
-            writer.Write(this.y);
-        }
-        public void Read (Reader reader) {
-            this.x = reader.ReadLong();
-            this.y = reader.ReadLong();
-        }
-    }
+		#endregion
+
+		public override bool Equals (object obj)
+		{
+			if (obj is Vector2d) {
+				return (Vector2d)obj == this;
+			}
+			return false;
+		}
+
+		#region Operators
+		public static Vector2d operator + (Vector2d v1, Vector2d v2)
+		{
+			return new Vector2d (v1.x + v2.x, v1.y + v2.y);
+		}
+		public static Vector2d operator - (Vector2d v1, Vector2d v2)
+		{
+			return new Vector2d (v1.x - v2.x, v1.y - v2.y);
+		}
+		public static Vector2d operator * (Vector2d v1, long mag)
+		{
+			return new Vector2d ((v1.x * mag) >> FixedMath.SHIFT_AMOUNT, (v1.y * mag) >> FixedMath.SHIFT_AMOUNT);
+		}
+		public static Vector2d operator * (Vector2d v1, int mag)
+		{
+			return new Vector2d ((v1.x * mag), (v1.y * mag));
+		}
+		public static Vector2d operator / (Vector2d v1, long div)
+		{
+			return new Vector2d (((v1.x << FixedMath.SHIFT_AMOUNT) / div), (v1.y << FixedMath.SHIFT_AMOUNT)/ div);
+		}
+		public static Vector2d operator / (Vector2d v1, int div)
+		{
+			return new Vector2d ((v1.x / div), v1.y / div);
+		}
+		public static Vector2d operator >> (Vector2d v1, int shift)
+		{
+			return new Vector2d (v1.x >> shift, v1.y >> shift);
+		}
+		public static bool operator == (Vector2d v1, Vector2d v2)
+		{
+			return v1.x == v2.x && v1.y == v2.y;
+		}
+		public static bool operator != (Vector2d v1, Vector2d v2)
+		{
+			return v1.x != v2.x || v1.y != v2.y;
+		}
+		#endregion
+
+		public long GetLongHashCode ()
+		{
+			return x * 31 + y * 7;
+		}
+
+        public int GetStateHash () {
+            return (int)(GetLongHashCode () % int.MaxValue);
+        }
+
+	}
 
 
 }
diff --git a/Core/Simulation/Math/Vector2dHeight.cs b/Core/Simulation/Math/Vector2dHeight.cs
index 52488725..f62e8fc3 100644
--- a/Core/Simulation/Math/Vector2dHeight.cs
+++ b/Core/Simulation/Math/Vector2dHeight.cs
@@ -5,7 +5,7 @@
 namespace Lockstep
 {
 	[Serializable]
-	public struct Vector2dHeight : ICommandData
+	public struct Vector2dHeight
 	{
 		[SerializeField, FixedNumber]
 		private long
@@ -21,19 +21,13 @@ public long X {
 		public long Y { get {return _y;}}
 
 		[SerializeField]
-		private long _height;
-		public long Height {get {return _height;}}
-
-        public Vector2dHeight (Vector2d vec) {
-            _x = vec.x;
-            _y = vec.y;
-            _height = 0;
-        }
+		private float _height;
+		public float Height {get {return _height;}}
 
 		public Vector2dHeight (Vector3 vec3) {
 			_x = FixedMath.Create (vec3.x);
 			_y = FixedMath.Create (vec3.z);
-            _height = FixedMath.Create(vec3.y);
+			_height = vec3.y;
 		}
 
 		public Vector2d ToVector2d () {
@@ -43,23 +37,11 @@ public Vector2d ToOrientedVector2d () {
 			return new Vector2d (_y, -_x);
 		}
         public Vector3 ToVector3 () {
-            return new Vector3(_x.ToFloat(), _height.ToFloat(), _y.ToFloat());
+            return new Vector3(_x.ToFloat(), _height, _y.ToFloat());
         }
         public override string ToString()
         {
-            return string.Format("({0}, {1}, {2})", X.ToFloat(), Height.ToFloat(), Y.ToFloat());
-        }
-
-        public void Write (Writer writer) {
-            writer.Write(this._x);
-            writer.Write(this._y);
-            writer.Write(this._height);
-        }
-
-        public void Read (Reader reader) {
-            this._x = reader.ReadLong();
-            this._y = reader.ReadLong();
-            this._height = reader.ReadLong();
+            return string.Format("({0}, {1}, {2})", X.ToFloat(), Height, Y.ToFloat());
         }
 
         public static explicit operator Vector2dHeight (Vector3 vec3) {
diff --git a/Core/Simulation/Math/VectorRotation.cs b/Core/Simulation/Math/VectorRotation.cs
index 774e4723..09192e8f 100644
--- a/Core/Simulation/Math/VectorRotation.cs
+++ b/Core/Simulation/Math/VectorRotation.cs
@@ -4,7 +4,6 @@
 
 namespace Lockstep
 {
-    //TODO: Make this an attribute for Vector2d
     [Serializable]
     public struct VectorRotation
     {
diff --git a/Core/Simulation/Physics/Core/CollisionPair.cs b/Core/Simulation/Physics/Core/CollisionPair.cs
index 0e654b35..516caa52 100644
--- a/Core/Simulation/Physics/Core/CollisionPair.cs
+++ b/Core/Simulation/Physics/Core/CollisionPair.cs
@@ -24,12 +24,11 @@ public class CollisionPair
         public static long PenetrationX;
         public static long PenetrationY;
         public static CollisionPair CurrentCollisionPair;
-
-        bool IsValid { get; set; }
+        bool IsValid {get; set;}
 
         public void Initialize(LSBody b1, LSBody b2)
         {
-            IsValid = PhysicsManager.RequireCollisionPair(b1, b2);
+            IsValid = PhysicsManager.RequireCollisionPair(b1,b2);
 
             PartitionVersion = 0;
             Body1 = b1;
@@ -43,8 +42,7 @@ public void Initialize(LSBody b1, LSBody b2)
 
             CacheSqrDistance = b1.Radius + b2.Radius;
             CacheSqrDistance *= CacheSqrDistance;
-            if (!IsValid)
-                return;
+            if (!IsValid) return;
 
             LeCollisionType = CollisionType.None;
             if (Body1.Shape == ColliderType.None || Body2.Shape == ColliderType.None)
@@ -106,8 +104,7 @@ public void Deactivate()
         private void DistributeCollision()
         {
 
-            if (Body1 == Body2)
-                Debug.Log("boom");
+
             if (Body1.OnContact.IsNotNull())
             {
                 Body1.OnContact(Body2);
@@ -117,113 +114,116 @@ private void DistributeCollision()
                 Body2.OnContact(Body1);
             }
 
-            switch (LeCollisionType)
+            if (DoPhysics && Body1.HasParent == false && Body2.HasParent == false)
             {
-                case CollisionType.Circle_Circle:
-                    DistX = Body1._position.x - Body2._position.x;
-                    DistY = Body1._position.y - Body2._position.y;
-                    dist = FixedMath.Sqrt((DistX * DistX + DistY * DistY) >> FixedMath.SHIFT_AMOUNT);
+                switch (LeCollisionType)
+                {
+                    case CollisionType.Circle_Circle:
+                        DistX = Body1._position.x - Body2._position.x;
+                        DistY = Body1._position.y - Body2._position.y;
+                        dist = FixedMath.Sqrt((DistX * DistX + DistY * DistY) >> FixedMath.SHIFT_AMOUNT);
                         
-                    if (dist == 0)
-                    {
-                        const int randomMax = (int)((long)int.MaxValue % (FixedMath.One / 64));
-                        Body1._position.x += LSUtility.GetRandom(randomMax) - randomMax / 2;
-                        Body1._position.y += LSUtility.GetRandom(randomMax) - randomMax / 2;
-                        Body1.PositionChanged = true;
-                        Body2._position.x += LSUtility.GetRandom(randomMax) - randomMax / 2;
-                        Body2._position.y += LSUtility.GetRandom(randomMax) - randomMax / 2;
-                        Body2.PositionChanged = true;
-                        return;
-                    }
+                        if (dist == 0)
+                        {
+                            const int randomMax = (int)((long)int.MaxValue % (FixedMath.One / 64));
+                            Body1._position.x += LSUtility.GetRandom(randomMax);
+                            Body1._position.y += LSUtility.GetRandom(randomMax);
+                            Body1.PositionChanged = true;
+                            Body2._position.x += LSUtility.GetRandom(randomMax);
+                            Body2._position.y += LSUtility.GetRandom(randomMax);
+                            Body2.PositionChanged = true;
+                            return;
+                        }
 
 
-                    depth = (Body1.Radius + Body2.Radius - dist);
+                        depth = (Body1.Radius + Body2.Radius - dist);
 
-                    if (depth <= 0)
-                    {
-                        return;
-                    }
-                    DistX = (DistX * depth / dist) / 2L;
-                    DistY = (DistY * depth / dist) / 2L;
+                        if (depth <= 0)
+                        {
+                            return;
+                        }
+                        DistX = (DistX * depth / dist) / 2L;
+                        DistY = (DistY * depth / dist) / 2L;
 
-                    const bool applyVelocity = false;
+                        const bool applyVelocity = true;
                     //Resolving collision
-                    if (Body1.Immovable || (Body2.Immovable == false && Body1.Priority > Body2.Priority))
-                    {
-                        Body2._position.x -= DistX;
-                        Body2._position.y -= DistY;
-                        Body2.PositionChanged = true;
-                        if (applyVelocity)
+                        if (Body1.Immovable || (Body2.Immovable == false && Body1.Priority > Body2.Priority))
+                        {
+                            Body2._position.x -= DistX;
+                            Body2._position.y -= DistY;
+                            Body2.PositionChanged = true;
+                            if (applyVelocity)
+                            {
+                                Body2._velocity.x -= DistX;
+                                Body2._velocity.y -= DistY;
+                                Body2.VelocityChanged = true;
+                            }
+                        } else if (Body2.Immovable || Body2.Priority > Body1.Priority)
                         {
-                            Body2._velocity.x -= DistX;
-                            Body2.VelocityChanged = true;
-                        }
-                    } else if (Body2.Immovable || Body2.Priority > Body1.Priority)
-                    {
 
-                        Body1._position.x += DistX;
-                        Body1._position.y += DistY;
-                        Body1.PositionChanged = true;
-                        if (applyVelocity)
+                            Body1._position.x += DistX;
+                            Body1._position.y += DistY;
+                            Body1.PositionChanged = true;
+                            if (applyVelocity)
+                            {
+                                Body1._velocity.x += DistX;
+                                Body1._velocity.y += DistY;
+                                Body1.VelocityChanged = true;
+                            }
+                        } else
                         {
-                            Body1._velocity.x += DistX;
-                            Body1._velocity.y += DistY;
-                            Body1.VelocityChanged = true;
-                        }
-                    } else
-                    {
-                        DistX /= 2;
-                        DistY /= 2;
+                            DistX /= 2;
+                            DistY /= 2;
 
-                        Body1._position.x += DistX;
-                        Body1._position.y += DistY;
-                        Body2._position.x -= DistX;
-                        Body2._position.y -= DistY;
+                            Body1._position.x += DistX;
+                            Body1._position.y += DistY;
+                            Body2._position.x -= DistX;
+                            Body2._position.y -= DistY;
                         
-                        Body1.PositionChanged = true;
-                        Body2.PositionChanged = true;
-                        if (applyVelocity)
-                        {
+                            Body1.PositionChanged = true;
+                            Body2.PositionChanged = true;
+                            if (applyVelocity)
+                            {
 
-                            DistX /= 8;
-                            DistY /= 8;
-                            Body1._velocity.x += DistX;
-                            Body1._velocity.y += DistY;
-                            Body1.VelocityChanged = true;
+                                DistX /= 8;
+                                DistY /= 8;
+                                Body1._velocity.x += DistX;
+                                Body1._velocity.y += DistY;
+                                Body1.VelocityChanged = true;
                             
-                            Body2._velocity.x -= DistX;
-                            Body2._velocity.y -= DistY;
-                            Body2.VelocityChanged = true;
+                                Body2._velocity.x -= DistX;
+                                Body2._velocity.y -= DistY;
+                                Body2.VelocityChanged = true;
+                            }
                         }
-                    }
-                    break;
-                case CollisionType.Circle_AABox:
-                    if (Body1.Shape == ColliderType.AABox)
-                    {
-                        DistributeCircle_Box(Body1, Body2);
-                    } else
-                    {
-                        DistributeCircle_Box(Body2, Body1);
-                    }
-                    break;
+                        break;
+                    case CollisionType.Circle_AABox:
+                        if (Body1.Shape == ColliderType.AABox)
+                        {
+                            DistributeCircle_Box(Body1, Body2);
+                        } else
+                        {
+                            DistributeCircle_Box(Body2, Body1);
+                        }
+                        break;
                             
-                case CollisionType.Circle_Polygon:
+                    case CollisionType.Circle_Polygon:
 
-                    break;
+                        break;
+                }
             }
 
-
         }
 
         public void CheckAndDistributeCollision()
         {
 
-            if (!Active)
+            if (!Active || Body1.HasParent || Body2.HasParent)
             {
                 return;
             }
             CurrentCollisionPair = this;
-            if (CheckHeight())
+
             if (CheckCollision())
             {
                 if (IsColliding == false)
@@ -263,14 +263,9 @@ public void CheckAndDistributeCollision()
 
         }
 
-        public bool CheckHeight()
-        {
-            return Body1.HeightMax >= Body2.HeightMin && Body1.HeightMin <= Body2.HeightMax;
-        }
-
         public bool CheckCollision()
         {
-            if ((Body1.PositionChanged || Body2.PositionChanged /*|| Body1.PositionChangedBuffer || Body2.PositionChangedBuffer*/) == false)
+            if ((Body1.PositionChanged || Body2.PositionChanged || Body1.PositionChangedBuffer || Body2.PositionChangedBuffer) == false)
             {
                 return IsColliding;
             }
@@ -397,7 +392,13 @@ public bool CheckCircle()
                 return true;
             }
 
-
+            /*if (Body1.VelocityFastMagnitude != 0 || Body2.VelocityFastMagnitude != 0) {
+                DistX = Body1.FuturePosition.x - Body2.FuturePosition.x;
+                DistY = Body1.FuturePosition.y - Body2.FuturePosition.y;
+                if ((DistX * DistX + DistY * DistY) <= CacheSqrDistance) {
+                    return true;
+                }
+            }*/
 
             return false;
         }
@@ -417,7 +418,17 @@ public bool CheckBox()
                     }
                 }
             }
-
+            /*if (Body1.VelocityFastMagnitude != 0 || Body2.VelocityFastMagnitude != 0) {
+                if (Body1.FutureXMin < Body2.FutureXMax) {
+                    if (Body1.FutureXMax > Body2.FutureXMin) {
+                        if (Body1.FutureYMin < Body2.FutureYMax) {
+                            if (Body1.FutureYMax > Body2.FutureYMin) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }*/
             return false;
         }
 
@@ -541,7 +552,9 @@ public void DistributeCircle_Box(LSBody box, LSBody circle)
             //Resolving
             circle._position.x -= PenetrationX;//(PenetrationX * Multiplier) >> FixedMath.SHIFT_AMOUNT;
             circle._position.y -= PenetrationY;//(PenetrationY * Multiplier) >> FixedMath.SHIFT_AMOUNT;
-
+            circle._velocity.x -= PenetrationX;
+            circle._velocity.y -= PenetrationY;
+            circle.VelocityChanged = true;
             circle.PositionChanged = true;
             circle.BuildBounds();
         }
diff --git a/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs b/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs
deleted file mode 100644
index f2e6a129..00000000
--- a/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs
+++ /dev/null
@@ -1,276 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using UnityEditor;
-
-namespace Lockstep.Integration
-{
-    [CustomEditor(typeof(LSBody), true),UnityEditor.CanEditMultipleObjects]
-    public class EditorLSBody : Editor
-    {
-
-        SerializedProperty Shape;
-        //Enum
-        SerializedProperty IsTrigger;
-        //bool
-        SerializedProperty Layer;
-        //int
-        SerializedProperty HalfWidth;
-        //long
-        SerializedProperty HalfHeight;
-        //long
-        SerializedProperty Radius;
-        //long
-        SerializedProperty Immovable;
-        //bool
-        SerializedProperty Vertices;
-        //Vector2d[]
-        SerializedProperty Height;
-        //long
-        SerializedProperty PositionalTransform;
-        //transform
-        SerializedProperty RotationalTransform;
-        //transform
-
-        SerializedObject so { get { return base.serializedObject; } }
-
-        bool MoreThanOne;
-
-        void OnEnable()
-        {
-            MoreThanOne = targets.Length > 1;
-            Shape = so.FindProperty("_shape");
-            IsTrigger = so.FindProperty("_isTrigger");
-            Layer = so.FindProperty("_layer");
-            HalfWidth = so.FindProperty("_halfWidth");
-            HalfHeight = so.FindProperty("_halfHeight");
-            Radius = so.FindProperty("_radius");
-            Immovable = so.FindProperty("_immovable");
-            Vertices = so.FindProperty("_vertices");
-            Height = so.FindProperty("_height");
-            PositionalTransform = so.FindProperty("_positionalTransform");
-            RotationalTransform = so.FindProperty("_rotationalTransform");
-        }
-
-        public override void OnInspectorGUI()
-        {
-            if (Application.isPlaying == false)
-            {
-
-                EditorGUI.BeginChangeCheck();
-                if (targets.Length == 1)
-                {
-                    PositionalTransform.Draw();
-                    RotationalTransform.Draw();
-                }
-
-                Shape.Draw();
-                ColliderType shape = (ColliderType)Shape.intValue;
-                if (shape != ColliderType.None)
-                {
-
-                    EditorGUILayout.Space();
-                    EditorGUILayout.LabelField("General Collider Settings", EditorStyles.boldLabel);
-                    Layer.Draw();
-                    IsTrigger.Draw();
-                    if (IsTrigger.boolValue == false)
-                        Immovable.Draw();
-                    Height.Draw();
-
-                    EditorGUILayout.Space();
-                    EditorGUILayout.LabelField("Collider Settings", EditorStyles.boldLabel); 
-                    if (shape == ColliderType.Circle)
-                    {
-                        Radius.Draw();
-                    } else if (shape == ColliderType.AABox)
-                    {
-                        HalfWidth.Draw();
-                        HalfHeight.Draw();
-                    } else if (shape == ColliderType.Polygon)
-                    {
-                        EditorGUIUtility.LookLikeControls();
-
-
-                        Vertices.Draw();
-                    }
-                }
-                SceneView.RepaintAll();
-                if (true)//EditorGUI.EndChangeCheck())
-                {
-                    so.ApplyModifiedProperties();
-                }
-            } else
-            {
-                //Debug view when playing
-                EditorGUILayout.LabelField("Runtime Debugging", EditorStyles.boldLabel);
-                base.OnInspectorGUI();
-            }
-        }
-
-        void OnSceneGUI()
-        {
-            
-            if (MoreThanOne)
-                return;
-
-            //Have to reinitialize everything because can't apply modified properties on base.serializedObject
-            SerializedObject so = new SerializedObject(target);
-            so.Update();
-            SerializedProperty Shape = so.FindProperty("_shape");
-            SerializedProperty IsTrigger = so.FindProperty("_isTrigger");
-            SerializedProperty Layer = so.FindProperty("_layer");
-            SerializedProperty HalfWidth = so.FindProperty("_halfWidth");
-            SerializedProperty HalfHeight = so.FindProperty("_halfHeight");
-            SerializedProperty Radius = so.FindProperty("_radius");
-            SerializedProperty Immovable = so.FindProperty("_immovable");
-            SerializedProperty Vertices = so.FindProperty("_vertices");
-            SerializedProperty Height = so.FindProperty("_height");
-            SerializedProperty PositionalTransform = so.FindProperty("_positionalTransform");
-            SerializedProperty RotationalTransform = so.FindProperty("_rotationalTransform");
-
-            ColliderType shape = (ColliderType)Shape.intValue;
-            if (shape == ColliderType.None)
-                return;
-            Handles.color = Color.blue;
-            Vector3 targetPos = (target as LSBody).transform.position;
-            const int ImprecisionLimit = 100000;
-            if (Mathf.Abs(targetPos.x) >= ImprecisionLimit ||
-                Mathf.Abs(targetPos.y) >= ImprecisionLimit ||
-                Mathf.Abs(targetPos.z) >= ImprecisionLimit)
-                return;
-            const float dragHandleSize = .5f;
-            const float spread = .02f;
-            int spreadMin = -1;
-            int spreadMax = 1;
-            Handles.DrawCapFunction dragCap = Handles.SphereCap;
-
-            float xModifier = 0f;
-            if (shape == ColliderType.Circle)
-            {
-                //targetPos.x - Radius.longValue.ToFloat ():
-                //Minus so the move handle doesn't end up on the same axis as the transform.position move handle
-                Radius.longValue =
-                    FixedMath.Create(
-                    Mathf.Abs(
-                        (Handles.FreeMoveHandle(
-                            new Vector3(targetPos.x - Radius.longValue.ToFloat(), targetPos.y, targetPos.z)
-                                , Quaternion.identity,
-                            dragHandleSize,
-                            Vector3.zero,
-                            Handles.SphereCap))
-                            .x - targetPos.x) 
-                );
-                Handles.DrawLine(targetPos, new Vector3(targetPos.x + Radius.longValue.ToFloat(), targetPos.y, targetPos.z));
-                float baseHeight = targetPos.y;
-                for (int i = spreadMin; i <= spreadMax; i++)
-                {
-                    Handles.CircleCap(
-                        1,
-                        new Vector3(targetPos.x, baseHeight + (float)i * spread, targetPos.z)
-                        , Quaternion.Euler(90, 0, 0), Radius.longValue.ToFloat());
-                }
-                baseHeight = targetPos.y + Height.longValue.ToFloat();
-                for (int i = spreadMin; i <= spreadMax; i++)
-                {
-                    Handles.CircleCap(
-                        1,
-                        new Vector3(targetPos.x, baseHeight + (float)i * spread, targetPos.z)
-                        , Quaternion.Euler(90, 0, 0), Radius.longValue.ToFloat());
-                }
-                xModifier = Radius.longValue.ToFloat();
-
-            } else if (shape == ColliderType.AABox)
-            {
-                HalfWidth.longValue =
-                    FixedMath.Create(
-                    (double)Mathf.Abs(
-                        Handles.FreeMoveHandle(
-                            new Vector3(targetPos.x - (float)HalfWidth.longValue.ToFormattedDouble(), targetPos.y, targetPos.z),
-                            Quaternion.identity,
-                            dragHandleSize,
-                            Vector3.zero,
-                            dragCap)
-                            .x - targetPos.x)
-                );
-                HalfHeight.longValue =
-                    FixedMath.Create(
-                    (double)System.Math.Abs(
-                        Handles.FreeMoveHandle(
-                            new Vector3(targetPos.x, targetPos.y, targetPos.z - (float)HalfHeight.longValue.ToFormattedDouble()),
-                            Quaternion.identity,
-                            dragHandleSize,
-                            Vector3.zero,
-                            dragCap)
-                            .z - targetPos.z)
-                );
-                float halfWidth = HalfWidth.longValue.ToFloat();
-                float halfHeight = HalfHeight.longValue.ToFloat();
-                for (int i = 0; i < 1; i++)
-                {
-                    float height = targetPos.y + (float)i * spread;
-                    Vector3[] lines = new Vector3[]
-                    {
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z + halfHeight),
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z - halfHeight),
-
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z - halfHeight),
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z - halfHeight),
-
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z - halfHeight),
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z + halfHeight),
-
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z + halfHeight),
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z + halfHeight)
-                    };
-                    Handles.DrawLines(lines);
-                }
-                for (int i = 0; i < 1; i++)
-                {
-                    float height = targetPos.y + (float)i * spread + Height.longValue.ToFloat();
-                    Vector3[] lines = new Vector3[]
-                    {
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z + halfHeight),
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z - halfHeight),
-
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z - halfHeight),
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z - halfHeight),
-
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z - halfHeight),
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z + halfHeight),
-
-                        new Vector3(targetPos.x - halfWidth, height, targetPos.z + halfHeight),
-                        new Vector3(targetPos.x + halfWidth, height, targetPos.z + halfHeight)
-                    };
-                    Handles.DrawLines(lines);
-                }
-
-                xModifier = halfWidth;
-            }
-            Handles.DrawLine(
-                new Vector3(targetPos.x + xModifier, targetPos.y, targetPos.z), 
-                new Vector3(targetPos.x + xModifier, targetPos.y + Height.longValue.ToFloat(), targetPos.z));
-
-            Vector3 movePos = targetPos;
-            movePos.x += xModifier;
-            movePos.y += (float)Height.longValue.ToFormattedDouble();
-            movePos = 
-                Handles.FreeMoveHandle(
-                movePos,
-                Quaternion.identity,
-                dragHandleSize,
-                Vector3.zero,
-                dragCap
-            );
-            Height.longValue = FixedMath.Create(Mathf.Max(Mathf.Abs(movePos.y - targetPos.y)));
-            so.ApplyModifiedProperties();
-        }
-    }
-
-    internal static class SerializedPropertyDraw
-    {
-        public static void Draw(this SerializedProperty prop)
-        {
-            EditorGUILayout.PropertyField(prop, true);
-
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs.meta b/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs.meta
deleted file mode 100644
index 5efecd46..00000000
--- a/Core/Simulation/Physics/Core/Editor/EditorLSBody.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 4841998ebf12542f6aee7f629e9194fa
-timeCreated: 1450833973
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Core/LSBody.cs b/Core/Simulation/Physics/Core/LSBody.cs
index f294ba39..b86afeed 100644
--- a/Core/Simulation/Physics/Core/LSBody.cs
+++ b/Core/Simulation/Physics/Core/LSBody.cs
@@ -6,750 +6,644 @@
 //=======================================================================
 
 using UnityEngine;
-using UnityEngine.Serialization;
 
 namespace Lockstep
 {
-    public sealed partial class LSBody : MonoBehaviour
-    {
-        #region Core deterministic variables
-
-        [SerializeField] //For inspector debugging
-        internal Vector2d _position;
-        [SerializeField]
-        internal Vector2d _rotation = Vector2d.up;
-        [SerializeField]
-        internal long _heightPos;
-        [SerializeField]
-        public Vector2d _velocity;
-
-        #endregion
-
-        #region Lockstep variables
-
-        [Lockstep]
-        public bool PositionChanged { get; set; }
-
-        [Lockstep]
-        public Vector2d Position
-        {
-            get
-            {
-                return _position;
-            }
-            set
-            {
-                _position = value;
-                this.PositionChanged = true;
-            }
-        }
-
-        private bool _rotationChanged;
-
-        [Lockstep]
-        public bool RotationChanged
-        {
-            get
-            {
-                return _rotationChanged;
-            }
-            set
-            {
-                _rotationChanged = value;
-            }
-        }
-
-
-        [Lockstep]
-        public Vector2d Rotation
-        {
-            get
-            {
-                return _rotation;
-            }
-            set
-            {
-                _rotation = value;
-                this.RotationChanged = true;
-            }
-        }
-
-        [Lockstep]
-        public bool HeightPosChanged { get; set; }
-
-        [Lockstep]
-        public long HeightPos
-        {
-            get { return _heightPos; }
-            set
-            {
-                _heightPos = value;
-                this.HeightPosChanged = true;
-            }
-        }
-
-        [Lockstep]
-        public bool VelocityChanged { get; set; }
-
-        [Lockstep]
-        public Vector2d Velocity
-        {
-            get { return _velocity; }
-            set
-            {
-                _velocity = value;
-                VelocityChanged = true;
-            }
-        }
-
-        public Vector2d LastPosition { get; private set; }
-
-        #endregion
-
-        internal Vector3 _visualPosition;
-
-        public Vector3 VisualPosition { get { return _visualPosition; } }
-
-        public LSAgent Agent { get; private set; }
-
-        public long FastRadius { get; private set; }
-
-        public bool PositionChangedBuffer { get; private set; }
-        //D
-        public bool SetPositionBuffer { get; private set; }
-        //ND
+	public class LSBody : MonoBehaviour
+	{
+		public Vector3 visualPosition;
+        public Vector2d _position;
 
 		
-        public bool RotationChangedBuffer { get; private set; }
-        //D
-        private bool SetRotationBuffer { get; set; }
-        //ND
-
-        bool SetVisualPosition { get; set; }
-
-        bool SetVisualRotation { get; set; }
-
-        private bool Setted { get; set; }
-
+		public LSAgent Agent { get; private set; }
 		
-        public long VelocityFastMagnitude { get; private set; }
-
-
-
-        private void AddChild(LSBody child)
-        {
-            if (Children == null)
-                Children = new FastBucket<LSBody>();
-            Children.Add(child);
-        }
-
-        private void RemoveChild(LSBody child)
-        {
-            Children.Remove(child);
-        }
-
-        private FastBucket<LSBody> Children;
-        public Vector2d[] RealPoints;
-        public Vector2d[] EdgeNorms;
-
-        
-        public long XMin { get; private set; }
-
-        public long XMax { get; private set; }
-
-        public long YMin { get; private set; }
-
-        public long YMax { get; private set; }
-
-        public int PastGridXMin;
-        public int PastGridXMax;
-        public int PastGridYMin;
-        public int PastGridYMax;
-
-        public long HeightMin { get; private set; }
-
-        public long HeightMax { get; private set; }
-
-        public delegate void CollisionFunction(LSBody other);
-
-        public CollisionFunction OnContactEnter;
-        public CollisionFunction OnContact;
-        public CollisionFunction OnContactExit;
-
-        public int ID { get; private set; }
+		public long FastRadius { get; private set; }
 
 		
-        public int Priority { get; set; }
-
-        #region Serialized
-
-        [SerializeField, FormerlySerializedAs("Shape")]
-        private ColliderType _shape = ColliderType.None;
-
-        public ColliderType Shape { get { return _shape; } }
-
-        [SerializeField, FormerlySerializedAs("IsTrigger")]
-        private bool _isTrigger;
-
-        public bool IsTrigger { get { return _isTrigger; } }
-
-        [SerializeField, FormerlySerializedAs("Layer")]
-        private int _layer;
-
-        public int Layer { get { return _layer; } }
-
-        [SerializeField,FixedNumber, FormerlySerializedAs("HalfWidth")]
-        private long _halfWidth = FixedMath.Half;
-
-        public long HalfWidth { get { return _halfWidth; } }
-
-        [SerializeField,FixedNumber, FormerlySerializedAs("HalfHeight")]
-        public long _halfHeight = FixedMath.Half;
-
-        public long HalfHeight { get { return _halfHeight; } }
-
-        [SerializeField,FixedNumber, FormerlySerializedAs("Radius")]
-        private long _radius = FixedMath.Half;
-
-        public long Radius { get { return _radius; } }
-
-        [SerializeField, FormerlySerializedAs("Immovable")]
-        private bool _immovable = false;
-        public bool Immovable;
-        [SerializeField, FormerlySerializedAs("_priority")]
-        private int _basePriority;
-
-        public int BasePriority { get { return _basePriority; } }
-
-        [SerializeField, FormerlySerializedAs("Vertices")]
-        private Vector2d[] _vertices;
-
-        public Vector2d[] Vertices { get { return _vertices; } }
-
-        [SerializeField, FixedNumber]
-        private long _height = FixedMath.One;
-
-        public long Height { get { return _height; } }
-
-        [SerializeField]
-        private Transform _positionalTransform;
-
-        public Transform PositionalTransform { get { return _positionalTransform; } }
-
-        private bool _canSetVisualPosition;
-        public bool CanSetVisualPosition {
-            get {
-                return _canSetVisualPosition;
-            }
-            set {
-                _canSetVisualPosition = value && _positionalTransform != null;
-            }
-        }
-
-        [SerializeField]
-        private Transform _rotationalTransform;
-
-        public Transform RotationalTransform { get { return _rotationalTransform; } }
-
-        private bool _canSetVisualRotation;
-        public bool CanSetVisualRotation {
-            get {
-                return _canSetVisualRotation;
-            }
-            set {
-                _canSetVisualRotation = value && _rotationalTransform;
-            }
-        }
-
-        #endregion
-
-        private Vector2d[] RotatedPoints;
-
-        public void Setup(LSAgent agent)
-        {
-            FastRadius = Radius * Radius;
-
-            if (Shape == ColliderType.Polygon)
-            {
-                Immovable = true;
-            }
-            if (Shape != ColliderType.None)
-            {
-                GeneratePoints();
-                GenerateBounds();
-            }
-            Agent = agent;
-            Setted = true;
-        }
-
-        public void GeneratePoints()
-        {
-            if (Shape != ColliderType.Polygon)
-            {
-                return;
-            }
-            RotatedPoints = new Vector2d[Vertices.Length];
-            for (int i = 0; i < Vertices.Length; i++)
-            {
-                RotatedPoints [i] = Vertices [i];
-                RotatedPoints [i].Rotate(_rotation.x, _rotation.y);
-            }
-            RealPoints = new Vector2d[Vertices.Length];
-            EdgeNorms = new Vector2d[Vertices.Length];
-        }
-
-        public void GenerateBounds()
-        {
-            if (Shape == ColliderType.Circle)
-            {
-                _radius = Radius;
-            } else if (Shape == ColliderType.AABox)
-            {
-                if (HalfHeight == HalfWidth)
-                {
-                    _radius = FixedMath.Sqrt((HalfHeight * HalfHeight * 2) >> FixedMath.SHIFT_AMOUNT);
-                } else
-                {
-                    _radius = FixedMath.Sqrt((HalfHeight * HalfHeight + HalfWidth * HalfWidth) >> FixedMath.SHIFT_AMOUNT);
-                }
+		public bool PositionChanged { get; set; }
+		
+		public bool PositionChangedBuffer { get; private set; } //D
+		public bool SetPositionBuffer; //ND
+		public Vector2d Rotation = Vector2d.up;
+		
+		public bool RotationChanged { get; set; }
+		
+		private bool RotationChangedBuffer { get; set; } //D
+		private bool SetRotationBuffer; //ND
 
-            } else if (Shape == ColliderType.Polygon)
-            {
-                long BiggestSqrRadius = Vertices [0].SqrMagnitude();
-                for (int i = 1; i < Vertices.Length; i++)
-                {
-                    long sqrRadius = Vertices [i].SqrMagnitude();
-                    if (sqrRadius > BiggestSqrRadius)
-                    {
-                        BiggestSqrRadius = sqrRadius;
-                    }
-                }
-                _radius = FixedMath.Sqrt(BiggestSqrRadius);
-            }
-        }
+		bool SetVisualPosition;
+		bool SetVisualRotation;
+		
+        public bool Setted {get; private set;}
 
-        public void Initialize(Vector2dHeight StartPosition, Vector2d StartRotation)
+		public Vector2d _velocity;
+		
+		public Vector2d Velocity {
+			get { return _velocity; }
+			set {
+				_velocity = value;
+				VelocityChanged = true;
+			}
+		}
+		
+		public long VelocityFastMagnitude { get; private set; }
+		
+		public bool VelocityChanged { get; set; }
+		
+		public LSBody Parent {
+			get { return HasParent ? _parent : null; }
+			set {
+				if (value != _parent) {
+					if (HasParent) {
+						_parent.RemoveChild (this);
+					}
+					if (value == null) {
+						HasParent = false;
+					} else {
+						if (value.HasParent) {
+							throw new System.Exception ("Cannot parent object to object with parent");
+						}
+						if (this.Children .IsNotNull () && this.Children.Count > 0) {
+							throw new System.Exception ("Cannot child object with children");
+						}
+						HasParent = true;
+						_parent = value;
+						_parent.AddChild (this);
+						this._positionalTransform.parent = _parent._positionalTransform;
+						this._rotationalTransform.parent = _parent._rotationalTransform;
+						UpdateLocalPosition ();
+						UpdateLocalRotation ();
+						LocalRotation = Rotation;
+						LocalRotation.Rotate (_parent.Rotation.x, _parent.Rotation.y); 
+						
+					}
+				}
+			}
+		}
+		
+		public bool HasParent { get; private set; }
+		
+		private void AddChild (LSBody child)
+		{
+			if (Children == null)
+				Children = new FastBucket<LSBody> ();
+			Children.Add (child);
+		}
+		
+		private void RemoveChild (LSBody child)
+		{
+			Children.Remove (child);
+		}
+		
+		private FastBucket<LSBody> Children;
+		public Vector2d[] RealPoints;
+		public Vector2d[] EdgeNorms;
+		public long XMin;
+		public long XMax;
+		public long YMin;
+		public long YMax;
+		public long PastGridXMin;
+		public long PastGridXMax;
+		public long PastGridYMin;
+		public long PastGridYMax;
+		
+		public delegate void CollisionFunction (LSBody other);
+		
+		public CollisionFunction OnContactEnter;
+		public CollisionFunction OnContact;
+		public CollisionFunction OnContactExit;
+		
+		public int ID { get; private set; }
+		
+		[SerializeField]
+		private int
+			_priority;
+		
+		public int Priority { get; set; }
+		
+		public uint RaycastVersion;
+		
+		#region Serialized
+		public ColliderType Shape;
+		public bool IsTrigger;
+		public  int Layer;
+        public long HalfWidth = FixedMath.Half;
+        public long HalfHeight = FixedMath.Half;
+		public long Radius;
+		public bool Immovable;
+	
+		public Transform _positionalTransform;
+		public Transform _rotationalTransform;
+		#endregion
+		
+		private LSBody _parent;
+		private Vector2d[] RotatedPoints;
+		public Vector2d LocalPosition;
+		public Vector2d LocalRotation;
+		public Vector2d[] Vertices;
+		
+		public void Setup (LSAgent agent)
+		{
+			FastRadius = Radius * Radius;
+			if (_positionalTransform == null)
+				_positionalTransform = base.transform;
+			if (_rotationalTransform == null)
+				_rotationalTransform = base.transform;
+			if (Shape == ColliderType.Polygon) {
+				Immovable = true;
+			}
+			if (Shape != ColliderType.None) {
+				GeneratePoints ();
+				GenerateBounds ();
+			}
+			Agent = agent;
+		}
+		
+		public void GeneratePoints ()
+		{
+			if (Shape != ColliderType.Polygon) {
+				return;
+			}
+			RotatedPoints = new Vector2d[Vertices.Length];
+			for (int i = 0; i < Vertices.Length; i++) {
+				RotatedPoints [i] = Vertices [i];
+				RotatedPoints [i].Rotate (Rotation.x, Rotation.y);
+			}
+			RealPoints = new Vector2d[Vertices.Length];
+			EdgeNorms = new Vector2d[Vertices.Length];
+		}
+		
+		public void GenerateBounds ()
+		{
+			if (Shape == ColliderType.Circle) {
+				Radius = Radius;
+			} else if (Shape == ColliderType.AABox) {
+				if (HalfHeight == HalfWidth) {
+					Radius = FixedMath.Sqrt ((HalfHeight * HalfHeight * 2) >> FixedMath.SHIFT_AMOUNT);
+				} else {
+					Radius = FixedMath.Sqrt ((HalfHeight * HalfHeight + HalfWidth * HalfWidth) >> FixedMath.SHIFT_AMOUNT);
+				}
+
+			} else if (Shape == ColliderType.Polygon) {
+				long BiggestSqrRadius = Vertices [0].SqrMagnitude ();
+				for (int i = 1; i < Vertices.Length; i++) {
+					long sqrRadius = Vertices [i].SqrMagnitude ();
+					if (sqrRadius > BiggestSqrRadius) {
+						BiggestSqrRadius = sqrRadius;
+					}
+				}
+				Radius = FixedMath.Sqrt (BiggestSqrRadius);
+			}
+		}
+		
+		public void InitializeSerialized ()
+		{
+            Initialize (this._position, Rotation);
+		}
+		
+		public void Initialize (Vector2d startPosition)
+		{
+			Initialize (startPosition, Rotation);
+		}
+		
+		public void Initialize (Vector2d StartPosition, Vector2d StartRotation)
         {
-            if (!Setted)
-            {
+            if (!Setted) {
                 this.Setup(null);
+                Setted = true;
             }
-            CheckVariables();
+            CheckVariables ();
 
-
-            PositionChanged = true;
-            RotationChanged = true;
-            VelocityChanged = true;
-            PositionChangedBuffer = false;
-            RotationChangedBuffer = false;
+			Parent = null;
+			
+			PositionChanged = true;
+			RotationChanged = true;
+			VelocityChanged = true;
+			PositionChangedBuffer = false;
+			RotationChangedBuffer = false;
 			
-            Priority = _basePriority;
-            Velocity = Vector2d.zero;
-            VelocityFastMagnitude = 0;
-            _position = StartPosition.ToVector2d();
-            _heightPos = StartPosition.Height;
-            _rotation = StartRotation;
+			Priority = _priority;
+			Velocity = Vector2d.zero;
+			VelocityFastMagnitude = 0;
+			_position = StartPosition;
+			Rotation = StartRotation;
+
 
-            XMin = 0;
-            XMax = 0;
-            YMin = 0;
-            YMax = 0;
+			_parent = null;
+			LocalPosition = Vector2d.zero;
+			LocalRotation = Vector2d.up;
 			
+			XMin = 0;
+			XMax = 0;
+			YMin = 0;
+			YMax = 0;
 			
-            PastGridXMin = int.MaxValue;
-            PastGridXMax = int.MaxValue;
-            PastGridYMin = int.MaxValue;
-            PastGridYMax = int.MaxValue;
 			
-            if (Shape != ColliderType.None)
-            {
-                BuildPoints();
-                BuildBounds();
-            }
+			PastGridXMin = long.MaxValue;
+			PastGridXMax = long.MaxValue;
+			PastGridYMin = long.MaxValue;
+			PastGridYMax = long.MaxValue;
 			
-            ID = PhysicsManager.Assimilate(this);
-            Partition.PartitionObject(this);
-            if (_positionalTransform != null)
-            {
-                CanSetVisualPosition = true;
-                _visualPosition = _position.ToVector3(HeightPos.ToFloat());
-                lastVisualPos = _visualPosition;
-                _positionalTransform.position = _visualPosition;
-            }
-            else {
-                CanSetVisualPosition = false;
-            }
-            if (_rotationalTransform != null)
-            {
-                CanSetVisualRotation = true;
-                visualRot = Quaternion.LookRotation(_rotation.ToVector3(0f));
-                lastVisualRot = visualRot;
-                _rotationalTransform.rotation = visualRot;
-            }
-            else {
-                CanSetVisualRotation = false;
-            }
-        }
-
-        void CheckVariables()
-        {
-
+			if (Shape != ColliderType.None) {
+				BuildPoints ();
+				BuildBounds ();
+			}
+			
+			ID = PhysicsManager.Assimilate (this);
+			Partition.PartitionObject (this);
+			
+			visualPosition = _position.ToVector3 (0f);
+			lastVisualPos = visualPosition;
+			_positionalTransform.position = visualPosition;
+            UnityEngine.Profiler.maxNumberOfSamplesPerFrame = 7000000;
+			visualRot = Quaternion.LookRotation (Rotation.ToVector3 (0f));
+			lastVisualRot = visualRot;
+			_positionalTransform.rotation = visualRot;
+		}
+
+        void CheckVariables () {
+            if (_positionalTransform == null)
+                this._positionalTransform = base.transform;
+            if (_rotationalTransform == null)
+                this._rotationalTransform = base.transform;
         }
-
-        public void BuildPoints()
-        {
-            if (Shape != ColliderType.Polygon)
-            {
-                return;
-            }
-            int VertLength = Vertices.Length;
+		
+		public void BuildPoints ()
+		{
+			if (Shape != ColliderType.Polygon) {
+				return;
+			}
+			int VertLength = Vertices.Length;
 			
-            if (RotationChanged)
-            {
-                for (int i = 0; i < VertLength; i++)
-                {
-                    RotatedPoints [i] = Vertices [i];
-                    RotatedPoints [i].Rotate(_rotation.x, _rotation.y);
+			if (RotationChanged) {
+				for (int i = 0; i < VertLength; i++) {
+					RotatedPoints [i] = Vertices [i];
+					RotatedPoints [i].Rotate (Rotation.x, Rotation.y);
 					
-                    EdgeNorms [i] = RotatedPoints [i];
-                    if (i == 0)
-                    {
-                        EdgeNorms [i].Subtract(ref RotatedPoints [VertLength - 1]);
-                    } else
-                    {
-                        EdgeNorms [i].Subtract(ref RotatedPoints [i - 1]);
-                    }
-                    EdgeNorms [i].Normalize();
-                    EdgeNorms [i].RotateRight();
-                }
-            }
-            for (int i = 0; i < Vertices.Length; i++)
-            {
-                RealPoints [i].x = RotatedPoints [i].x + _position.x;
-                RealPoints [i].y = RotatedPoints [i].y + _position.y;
-            }
-        }
-
-        public void BuildBounds()
-        {
-            HeightMin = HeightPos;
-            HeightMax = HeightPos + Height;
-            if (Shape == ColliderType.Circle)
-            {
-                XMin = -Radius + _position.x;
-                XMax = Radius + _position.x;
-                YMin = -Radius + _position.y;
-                YMax = Radius + _position.y;
-            } else if (Shape == ColliderType.AABox)
-            {
-                XMin = -HalfWidth + _position.x;
-                XMax = HalfWidth + _position.x;
-                YMin = -HalfHeight + _position.y;
-                YMax = HalfHeight + _position.y;
-            } else if (Shape == ColliderType.Polygon)
-            {
-                XMin = _position.x;
-                XMax = _position.x;
-                YMin = _position.y;
-                YMax = _position.y;
-                for (int i = 0; i < Vertices.Length; i++)
-                {
-                    Vector2d vec = RealPoints [i];
-                    if (vec.x < XMin)
-                    {
-                        XMin = vec.x;
-                    } else if (vec.x > XMax)
-                    {
-                        XMax = vec.x;
-                    }
+					EdgeNorms [i] = RotatedPoints [i];
+					if (i == 0) {
+						EdgeNorms [i].Subtract (ref RotatedPoints [VertLength - 1]);
+					} else {
+						EdgeNorms [i].Subtract (ref RotatedPoints [i - 1]);
+					}
+					EdgeNorms [i].Normalize ();
+					EdgeNorms [i].RotateRight ();
+				}
+			}
+			for (int i = 0; i < Vertices.Length; i++) {
+				RealPoints [i].x = RotatedPoints [i].x + _position.x;
+				RealPoints [i].y = RotatedPoints [i].y + _position.y;
+			}
+		}
+		
+		public void BuildBounds ()
+		{
+			if (Shape == ColliderType.Circle) {
+				XMin = -Radius + _position.x;
+				XMax = Radius + _position.x;
+				YMin = -Radius + _position.y;
+				YMax = Radius + _position.y;
+			} else if (Shape == ColliderType.AABox) {
+				XMin = -HalfWidth + _position.x;
+				XMax = HalfWidth + _position.x;
+				YMin = -HalfHeight + _position.y;
+				YMax = HalfHeight + _position.y;
+			} else if (Shape == ColliderType.Polygon) {
+				XMin = _position.x;
+				XMax = _position.x;
+				YMin = _position.y;
+				YMax = _position.y;
+				for (int i = 0; i < Vertices.Length; i++) {
+					Vector2d vec = RealPoints [i];
+					if (vec.x < XMin) {
+						XMin = vec.x;
+					} else if (vec.x > XMax) {
+						XMax = vec.x;
+					}
 					
-                    if (vec.y < YMin)
-                    {
-                        YMin = vec.y;
-                    } else if (vec.y > YMax)
-                    {
-                        YMax = vec.y;
-                    }
-                }
-            }
-        }
-
-        public void EarlySimulate()
-        {
-            if (VelocityChanged)
-            {
-                VelocityFastMagnitude = _velocity.FastMagnitude();
-                VelocityChanged = false;
-            }
-            if (VelocityFastMagnitude != 0)
-            {
-
-                _position.x += _velocity.x;
-                _position.y += _velocity.y;
-                PositionChanged = true;
-            }
+					if (vec.y < YMin) {
+						YMin = vec.y;
+					} else if (vec.y > YMax) {
+						YMax = vec.y;
+					}
+				}
+			}
+		}
+		
+		public void EarlySimulate ()
+		{
+			if (HasParent)
+				return;
+
+			if (VelocityChanged) {
+				VelocityFastMagnitude = Velocity.FastMagnitude ();
+				VelocityChanged = false;
+			}
 			
-            if (PositionChanged || this.PositionChangedBuffer)
-            {
-                Partition.UpdateObject(this);
-            }
-            if (RotationChanged)
-            {
-            } else
-            {
-            }
-        }
-
-        public void Simulate()
-        {
-
-            if (PositionChanged || RotationChanged)
-            {
-                if (PositionChanged)
-                {
+			if (VelocityFastMagnitude != 0) {
+				_position.x += Velocity.x;
+				_position.y += Velocity.y;
+				PositionChanged = true;
+			}
+			
+			if (PositionChanged) {
+				Partition.UpdateObject (this);
+			}
+			if (RotationChanged) {
+			} else {
+			}
+		}
+		
+		public void Simulate ()
+		{
+			if (HasParent)
+				return;
+			
+			if (PositionChanged || RotationChanged) {
+				if (PositionChanged) {
 
-                } else
-                {
-                }
+				} else {
+				}
 				
-                if (RotationChanged)
-                {
-                } else
-                {
-                }
+				if (RotationChanged) {
+				} else {
+				}
 				
-            } else
-            {
+			} else {
 				
-            }
+			}
 			
-        }
-
-        public void LateSimulate()
-        {
-
-
-            BuildChangedValues();
-
-        }
-
+		}
 		
-        public void BuildChangedValues()
-        {
-            if (PositionChanged || RotationChanged)
-            {
-                BuildPoints();
-                BuildBounds();
-            }
-            if (PositionChanged)
-            {
-                LastPosition = _position;
-                PositionChangedBuffer = true;
-                PositionChanged = false;
-                this.SetVisualPosition = true;
-            } else
-            {
-                PositionChangedBuffer = false;
-                this.SetVisualPosition = false;
-            }
+		public void LateSimulate ()
+		{
+			if (HasParent) {
+				ChildSimulate ();
+			}
+			if (PhysicsManager.SetVisuals) {
+				SetVisuals ();
+			}
+			BuildChangedValues ();
+
+		}
+		
+		private void ChildSimulate ()
+		{
 			
-            if (RotationChanged)
-            {
+			if (_parent.RotationChangedBuffer) {
+				UpdateRotation ();
+				UpdatePosition ();
+			} else {
+				if (_parent.PositionChangedBuffer || this.PositionChanged) {
+					UpdatePosition ();
+				}
+				if (this.RotationChanged) {
+					UpdateRotation ();
+				}
+			}
+			
+		}
+		
+		public void BuildChangedValues ()
+		{
+			if (PositionChanged || RotationChanged) {
+				BuildPoints ();
+				BuildBounds ();
+			}
+			if (PositionChanged) {
+				PositionChangedBuffer = true;
+				PositionChanged = false;
+				this.SetVisualPosition = true;
+			} else {
+				PositionChangedBuffer = false;
+				this.SetVisualPosition = false;
+			}
+			
+			if (RotationChanged) {
 				
-
-                _rotation.Normalize();
-                RotationChangedBuffer = true;
-                RotationChanged = false;
-                this.SetVisualRotation = true;
-            } else
-            {
-                RotationChangedBuffer = false;
-                this.SetVisualRotation = false;
-
-            }
-        }
-
-        public void SetVisuals()
-        {
-
-
-
-            if (this.SetVisualPosition)
-            {
-                DoSetVisualPosition(
-                    _position.ToVector3(HeightPos.ToFloat())
-                );
-            }
+				if (HasParent)
+					LocalRotation.Normalize ();
+				else
+					Rotation.Normalize ();
+				RotationChangedBuffer = true;
+				RotationChanged = false;
+				this.SetVisualRotation = true;
+			} else {
+				RotationChangedBuffer = false;
+				this.SetVisualRotation = false;
+
+			}
+		}
+		private bool visualPositionReached;
+		private bool visualRotationReached;
+		private void SetVisuals () {
+
+			const bool test = false;
+			if (HasParent) {
+
+			}
+			else {
+				if (SetVisualPosition == false) {
+					if (visualPositionReached == false)
+					visualPositionReached = !(SetVisualPosition = _positionalTransform.position != visualPosition);
+				}
+				if (SetVisualRotation == false) {
+					if (visualRotationReached == false)
+					visualRotationReached = !(SetVisualRotation = _rotationalTransform.rotation != this.visualRot);
+				}
+			}
+			if (test || this.SetVisualPosition)
+			{
+				if (HasParent) {
+					this._positionalTransform.localPosition = this.LocalPosition.rotatedLeft.ToVector3 (visualPosition.y - _parent.visualPosition.y);
+				}
+				else {
+					lastVisualPos = visualPosition;
+					visualPosition.x = _position.x.ToFloat ();
+					visualPosition.z = _position.y.ToFloat ();
+					SetPositionBuffer = true;
+					visualPositionReached = false;
+				}
+			}
+			else if (HasParent == false){
+				if (SetPositionBuffer) {
+					//_positionalTransform.position = visualPosition;
+					SetPositionBuffer = false;
+				}
+			}
+
+			if (test || this.SetVisualRotation)
+			{
+				if (HasParent) {
+					this._rotationalTransform.localRotation = Quaternion.LookRotation (this.LocalRotation.rotatedLeft.ToVector3 (0f));
+				}
+				else {
+					lastVisualRot = visualRot;
+					visualRot = Quaternion.LookRotation (Rotation.ToVector3 (0f));
+					SetRotationBuffer = true;
+					visualRotationReached = false;
+				}
+			}
+			else if (HasParent == false) {
+				if (SetRotationBuffer) {
+					//_rotationalTransform.rotation = visualRot;
+					SetRotationBuffer = false;
+				}
+			}
+		}
+
+		Vector3 lastVisualPos;
+		Quaternion lastVisualRot;
+		Quaternion visualRot = Quaternion.identity;
+		public void Visualize ()
+		{
+			if (HasParent) return;
+
+			if (SetPositionBuffer) {
+				_positionalTransform.position = Vector3.Lerp (_positionalTransform.position,
+				                                              Vector3.Lerp (lastVisualPos, visualPosition, PhysicsManager.LerpTime),
+				                                             PhysicsManager.LerpDamping);
+			}
 			
-            if (this.SetVisualRotation)
-            {
-                DoSetVisualRotation(_rotation);
-            }
-        }
-
-        private void DoSetVisualPosition(Vector3 pos)
-        {
-            lastVisualPos = _visualPosition;
-            _visualPosition = pos;
-            SetPositionBuffer = true;
-        }
-
-        private void DoSetVisualRotation(Vector2d rot)
-        {
-            lastVisualRot = visualRot;
-            visualRot = Quaternion.LookRotation(rot.ToVector3(0f));
-            SetRotationBuffer = true;
-        }
-
-        public void SetExtrapolatedVisuals()
-        {
-            
-            if (this.SetVisualPosition)
-            {
-                Vector3 lastPos = this.lastVisualPos;
-                Vector3 curPos = this._position.ToVector3(_heightPos.ToFloat());
-                Vector3 delta = curPos - lastPos;
-                Vector3 prediction = lastPos + delta;
-                DoSetVisualPosition(prediction);
-            }
-            if (this.SetVisualRotation)
-            {
-            }
-
-        }
-
-        Vector3 lastVisualPos;
-        Quaternion lastVisualRot;
-        Quaternion visualRot = Quaternion.identity;
-
-        public void Visualize()
-        {
-            if (CanSetVisualPosition)
-            {
-                if (SetPositionBuffer)
-                {
-                    //Interpolates between the current position and the interpolation between the last lockstep position and the current lockstep position
-                    //LerpTime = time passed since last simulation frame
-                    //LerpDamping = special value calculated based on Time.deltaTime for the extra layer of interpolation
-                    _positionalTransform.position = Vector3.Lerp(_positionalTransform.position,
-                        Vector3.Lerp(lastVisualPos, _visualPosition, PhysicsManager.LerpTime),
-                        PhysicsManager.LerpDamping);
-                
-                }
-            }
-            const float rotationLerpDamping = .5f;
-            if (CanSetVisualRotation)
-            {
-                if (SetRotationBuffer)
-                {
-                    _rotationalTransform.rotation =
-                    Quaternion.Lerp(
-                        _rotationalTransform.rotation,
-                        Quaternion.LerpUnclamped(lastVisualRot, visualRot, PhysicsManager.LerpTime),
-                        rotationLerpDamping
-                    );
-                }
-            }
-        }
-
-        public void LerpOverReset()
-        {
-            SetPositionBuffer = false;
-            SetRotationBuffer = false;
-        }
-
-	
+			if (SetRotationBuffer) {
+				_rotationalTransform.rotation = Quaternion.Lerp(_rotationalTransform.rotation, Quaternion.LerpUnclamped (lastVisualRot, visualRot, PhysicsManager.LerpTime), PhysicsManager.LerpDamping * 2f);
+			}
+		}
+		public void LerpOverReset () {
+			if (HasParent) return;
+			SetPositionBuffer = false;
+			SetRotationBuffer = false;
+		}
 		
-        public void Rotate(long cos, long sin)
-        {
-
-            _rotation.Rotate(cos, sin);
-            RotationChanged = true;
-        }
-
-        public void SetRotation(long x, long y)
-        {
-            _rotation = new Vector2d(x, y);
-            RotationChanged = true;
-        }
-
-        public Vector2d TransformDirection(Vector2d worldPos)
-        {
-            worldPos -= _position;
-            worldPos.RotateInverse(_rotation.x, _rotation.y);
-            return worldPos;
-        }
-
-        public Vector2d InverseTransformDirection(Vector2d localPos)
-        {
-            localPos.Rotate(_rotation.x, _rotation.y);
-            localPos += _position;
-            return localPos;
-        }
-
-        public override int GetHashCode()
-        {
-            return ID;
-        }
-
-        public void Deactivate()
-        {
+		public void UpdateLocalPosition ()
+		{
+			if (HasParent) {
+				LocalPosition = _position - _parent._position;
+				LocalPosition.Rotate (_parent.Rotation.x, _parent.Rotation.y);
+			}
+		}
+		
+		public void UpdatePosition ()
+		{
+			if (HasParent) {
+				_position = LocalPosition;
+				_position.RotateInverse (_parent.Rotation.x, _parent.Rotation.y);
+				_position += _parent._position;
+				PositionChanged = true;
+			}
+		}
+		
+		public void UpdateRotation ()
+		{
+			if (HasParent) {
+				Rotation = LocalRotation;
+				Rotation.RotateInverse (_parent.Rotation.x, _parent.Rotation.y);
+				RotationChanged = true;
+			}
+		}
+		
+		public void UpdateLocalRotation ()
+		{
+			if (HasParent) {
+				LocalRotation = Rotation;
+				LocalRotation.Rotate (_parent.Rotation.x, _parent.Rotation.y);
+			}
+		}
+		
+		public void Rotate (long cos, long sin)
+		{
+			if (HasParent)
+				LocalRotation.Rotate (cos, sin);
+			else
+				Rotation.Rotate (cos, sin);
+			RotationChanged = true;
+		}
+		
+		public void SetRotation (long x, long y)
+		{
+			Rotation = new Vector2d (x, y);
+			RotationChanged = true;
+		}
+		
+		public Vector2d TransformDirection (Vector2d worldPos)
+		{
+			worldPos -= _position;
+			worldPos.RotateInverse (Rotation.x, Rotation.y);
+			return worldPos;
+		}
+		
+		public Vector2d InverseTransformDirection (Vector2d localPos)
+		{
+			localPos.Rotate (Rotation.x, Rotation.y);
+			localPos += _position;
+			return localPos;
+		}
+		
+		
+		public override int GetHashCode ()
+		{
+			return ID;
+		}
+		
+		public void Deactivate ()
+		{
+			Parent = null;
+			if (Children .IsNotNull ())
+			for (int i = 0; i < Children.PeakCount; i++) {
+				if (Children.arrayAllocation [i]) {
+					Children [i].Parent = null;
+				}
+			}
             PhysicsManager.Dessimilate(this);
-        }
-
-        public bool HeightOverlaps(long heightPos)
-        {
-            return heightPos >= HeightMin && heightPos <= HeightMax;
-        }
-
-        public bool HeightOverlaps(long heightMin, long heightMax)
-        {
-            return heightMax >= HeightMin && heightMin <= HeightMax;
-        }
-
-
-
-
-        long GetCeiledSnap(long f, long snap)
-        {
+		} 
+
+		public void Teleport (Vector2d destination) {
+			this._position = destination;
+			this.visualPosition = destination.ToVector3 (visualPosition.y);
+			this.lastVisualPos = visualPosition;
+			this._positionalTransform.position = visualPosition;
+		}
+		
+		public bool GetAgentAbility<T> (out T abil) where T : Ability{
+			if (Agent .IsNotNull ()) {
+				abil = Agent.GetAbility<T> ();
+				if (abil .IsNotNull ()) {
+					return true;
+				}
+			}
+			abil = null;
+			return false;
+		}
+
+        long GetCeiledSnap (long f, long snap) {
             return (f + snap - 1) / snap * snap;
         }
-
-        long GetFlooredSnap(long f, long snap)
-        {
+        long GetFlooredSnap (long f, long snap) {
             return (f / snap) * snap;
         }
-
-        public void GetCoveredSnappedPositions(long snapSpacing, FastList<Vector2d> output)
-        {
+        public void GetCoveredSnappedPositions (long snapSpacing, FastList<Vector2d> output) {
             long referenceX = 0,
             referenceY = 0;
-            long xmin = GetFlooredSnap(this.XMin - FixedMath.Half, snapSpacing);
-            long ymin = GetFlooredSnap(this.YMin - FixedMath.Half, snapSpacing);
+            long xmin = GetFlooredSnap (this.XMin - FixedMath.Half, snapSpacing);
+            long ymin = GetFlooredSnap (this.YMin - FixedMath.Half, snapSpacing);
 
-            long xmax = GetCeiledSnap(this.XMax + FixedMath.Half - xmin, snapSpacing) + xmin;
-            long ymax = GetCeiledSnap(this.YMax + FixedMath.Half - ymin, snapSpacing) + ymin;
+            long xmax = GetCeiledSnap (this.XMax + FixedMath.Half - xmin, snapSpacing) + xmin;
+            long ymax = GetCeiledSnap (this.YMax + FixedMath.Half - ymin, snapSpacing) + ymin;
             //Used for getting snapped positions this body covered
-            for (long x = xmin; x < xmax; x += snapSpacing)
-            {
-                for (long y = ymin; y < ymax; y += snapSpacing)
-                {
-                    Vector2d checkPos = new Vector2d(x, y);
-                    if (IsPositionCovered(checkPos))
-                    {
-                        output.Add(checkPos);
+            for (long x = xmin; x < xmax; x+= snapSpacing) {
+                for (long y = ymin; y < ymax; y += snapSpacing) {
+                    Vector2d checkPos = new Vector2d(x,y);
+                    if (IsPositionCovered (checkPos)) {
+                        output.Add (checkPos);
                     }
                 }
             }
         }
-
-        public bool IsPositionCovered(Vector2d position)
-        {
+        public bool IsPositionCovered (Vector2d position) {
             //Checks if this body covers a position
 
             //Different techniques for different shapes
-            switch (this.Shape)
-            {
+            switch (this.Shape) {
                 case ColliderType.Circle:
                     long maxDistance = this.Radius + FixedMath.Half;
                     maxDistance *= maxDistance;
@@ -758,43 +652,25 @@ public bool IsPositionCovered(Vector2d position)
                     goto case ColliderType.AABox;
                 case ColliderType.AABox:
                     return position.x + FixedMath.Half >= this.XMin && position.x - FixedMath.Half <= this.XMax
-                    && position.y + FixedMath.Half >= this.YMin && position.y - FixedMath.Half <= this.YMax;
+                        && position.y + FixedMath.Half >= this.YMin && position.y - FixedMath.Half <= this.YMax;
                     break;
             }
             return false;
         }
-
-        void Reset()
-        {
-            this._positionalTransform = this.transform;
-            this._rotationalTransform = this.transform;
-        }
-
-        void OnDrawGizmos()
-        {
-            return;
-            //Don't draw gizmos before initialization
-            if (Application.isPlaying == false)
-                return;
-            switch (this.Shape)
-            {
+        void OnDrawGizmos () {
+            switch (this.Shape) {
                 case ColliderType.Circle:
-                    Gizmos.DrawWireSphere(this._position.ToVector3(this.HeightPos.ToFloat()), this.Radius.ToFloat());
-                    break;
-                case ColliderType.AABox:
-                    Gizmos.DrawWireCube(
-                        this._position.ToVector3(this.HeightPos.ToFloat() + this.Height.ToFloat() / 2),
-                        new Vector3(this.HalfWidth.ToFloat() * 2, this.Height.ToFloat(), this.HalfHeight.ToFloat() * 2));
+                    Gizmos.DrawWireSphere(this._position.ToVector3(transform.position.y + .5f),this.Radius.ToFloat());
                     break;
             }
         }
-    }
-
-    public enum ColliderType : byte
-    {
-        None,
-        Circle,
-        AABox,
-        Polygon
-    }
+	}
+	
+	public enum ColliderType : byte
+	{
+		None,
+		Circle,
+		AABox,
+		Polygon
+	}
 }
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs b/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs
deleted file mode 100644
index 122c87d8..00000000
--- a/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using UnityEngine;
-using System.Collections;
-
-namespace Lockstep
-{
-    public partial class LSBody
-    {
-        private static Vector2d cacheAxis;
-        private static Vector2d cacheP1;
-        private static Vector2d cacheP2;
-        private static long axisMin;
-        private static long axisMax;
-        private static long cacheProjPerp;
-
-        public static void PrepareAxisCheck(Vector2d p1, Vector2d p2)
-        {
-            cacheP1 = p1;
-            cacheP2 = p2;
-            cacheAxis = p2 - p1;
-            cacheAxis.Normalize();
-            axisMin = p1.Dot(cacheAxis.x,cacheAxis.y);
-            axisMax = p2.Dot(cacheAxis.x,cacheAxis.y);
-            cacheProjPerp = cacheP1.Cross(cacheAxis.x,cacheAxis.y);
-        }
-
-        public bool Overlaps () {
-            //Checks if this object overlaps the line formed by p1 and p2
-            switch (this.Shape) {
-                case ColliderType.Circle:
-                    {
-                        //Check if the circle completely fits between the line
-                        long projPos = this._position.Dot(cacheAxis.x,cacheAxis.y);
-                        //Circle withing bounds?
-                        if (projPos >= axisMin && projPos <= axisMax) {
-                            long projPerp = this._position.Cross(cacheAxis.x,cacheAxis.y);
-
-                            if ((projPerp - cacheProjPerp).AbsMoreThan(_radius) == false) {
-                                return true;
-                            }
-                        }
-                        else {
-                            //If not, check distances to points
-                            long p1Dist = _position.FastDistance (cacheP1.x,cacheP2.y);
-                            if (p1Dist <= this.FastRadius)
-                                return true;
-                            long p2Dist = _position.FastDistance (cacheP2.x,cacheP2.y);
-                            if (p2Dist <= this.FastRadius)
-                                return true;
-                        }
-                    }
-                    break;
-                case ColliderType.AABox:
-                    {
-                      
-                    }
-                    break;
-            }
-            return false;
-        }
-        public Vector2d GetClosestPoint (Vector2d target) {
-            switch (this.Shape) {
-                case ColliderType.Circle:
-                    {
-                        Vector2d delta = this._position - target;
-                        long mag = delta.Magnitude();
-                        delta *= mag - this._radius;
-                        return target + delta;
-                    }
-                    break;
-            }
-            return this._position - target;
-        }
-        public long GetClosestDist (Vector2d target) {
-            switch (this.Shape) {
-                case ColliderType.Circle:
-                    {
-                        Vector2d delta = this._position - target;
-                        long mag = delta.Magnitude();
-                        return mag - this._radius;
-                    }
-                    break;
-            }
-            return (this._position - target).Magnitude();
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs.meta b/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs.meta
deleted file mode 100644
index 1c85fbae..00000000
--- a/Core/Simulation/Physics/Core/LSBodyOverlapCheck.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: a694d4f1f3d00473c9bd9e3052e7b78d
-timeCreated: 1451098888
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Core/Partition.cs b/Core/Simulation/Physics/Core/Partition.cs
index f339b63b..ad8dec8d 100644
--- a/Core/Simulation/Physics/Core/Partition.cs
+++ b/Core/Simulation/Physics/Core/Partition.cs
@@ -8,189 +8,100 @@
 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
-using System;
+
 namespace Lockstep
 {
 	public static class Partition
 	{
 		#region Settings
-		public const int DefaultCount = 64;
-        public const int AdditionalShiftSize = 2;
-        public const int ShiftSize = FixedMath.SHIFT_AMOUNT + AdditionalShiftSize;
-        public static int BoundX {get; private set;} //Lower bound X
-        public static int BoundY {get; private set;} //Lower bound Y
-        //Offset due to partition nodes being centered on grid positions
-        public const long Offset = (1 << ShiftSize) / 2;
-
+		public const int Count = 256;
+		public const int ShiftSize = FixedMath.SHIFT_AMOUNT + 2;
+		public const long OffsetX = -(1 << ShiftSize) * Count / 2;
+		public const long testX = -FixedMath.One * 32;
+		public const long OffsetY = -(1 << ShiftSize) * Count / 2;
 		#endregion
 
 		public static uint _Version = 1;
-        public static Array2D<PartitionNode> Nodes = new Array2D<PartitionNode> (DefaultCount, DefaultCount);
+		public static PartitionNode[] Nodes = new PartitionNode[Count * Count];
 		public static readonly FastBucket<PartitionNode> ActivatedNodes = new FastBucket<PartitionNode>();
-        private static readonly FastList<PartitionNode> AllocatedNodes = new FastList<PartitionNode>();
 
 		public static void Setup ()
 		{
 			_Version = 1;
-
-
-            BoundX = -DefaultCount / 2;
-            BoundY = -DefaultCount / 2;
-
+			for (int i = 0; i < Count * Count; i++) {
+				Nodes [i] = new PartitionNode ();
+			}
 		}
 
 		public static void Initialize () {
-            ActivatedNodes.FastClear ();
-            for (int i = AllocatedNodes.Count - 1; i >= 0; i--) {
-                AllocatedNodes[i].Reset ();
+			ActivatedNodes.FastClear ();
+			for (int i = 0; i < Count * Count; i++) {
+				Nodes[i].Initialize ();
 			}
 		}
 
-		static int GridXMin, GridXMax, GridYMin, GridYMax;
+		static long GridXMin, GridXMax, GridYMin, GridYMax;
 
-        public static void UpdateObject (LSBody Body) {
+        public static void UpdateObject(LSBody Body) {
 
-            GetGridBounds (Body);
+			GridXMin = (Body.XMin - OffsetX) >> ShiftSize;
+			GridXMax = ((Body.XMax - OffsetX) >> ShiftSize);
+			GridYMin = ((Body.YMin - OffsetY) >> ShiftSize);
+			GridYMax =((Body.YMax - OffsetY) >> ShiftSize);
+			#if UNITY_EDITOR
+			if (GridXMin < 0 || GridXMax >= Count || GridYMin < 0 || GridYMax >= Count)
+			{
+				Debug.LogError ("Body with ID " + Body.ID.ToString () + " is out of partition bounds.");
+				return;
+			}
+			#endif
 			if (Body.PastGridXMin != GridXMin ||
 				Body.PastGridXMax != GridXMax ||
 				Body.PastGridYMin != GridYMin ||
 				Body.PastGridYMax != GridYMax) {
-				for (int o = Body.PastGridXMin; o <= Body.PastGridXMax; o++) {
-					for (int p = Body.PastGridYMin; p <= Body.PastGridYMax; p++) {
-                        PartitionNode node = GetNode(o,p);
+				for (long o = Body.PastGridXMin; o <= Body.PastGridXMax; o++) {
+					for (long p = Body.PastGridYMin; p <= Body.PastGridYMax; p++) {
+						PartitionNode node = Nodes [o * Count + p];
 						node.Remove (Body.ID);
 					}
 				}
-                PartitionObject (Body, true);
+
+				for (long i = GridXMin; i <= GridXMax; i++) {
+					for (long j = GridYMin; j <= GridYMax; j++) {
+						PartitionNode node = Nodes [i * Count + j];
+
+						node.Add (Body.ID);
+					}
+				}
+
+
+				Body.PastGridXMin = GridXMin;
+				Body.PastGridXMax = GridXMax;
+				Body.PastGridYMin = GridYMin;
+				Body.PastGridYMax = GridYMax;
 			}
 		}
 
-        private static void GetGridBounds (LSBody Body) {
-            GridXMin = GetGridX (Body.XMin);
-            GridXMax = GetGridX (Body.XMax);
-            GridYMin = GetGridY (Body.YMin);
-            GridYMax = GetGridY (Body.YMax);
-            int iterationCount = 0;
-            while (CheckSize (GridXMin, GridXMax, GridYMin, GridYMax)) {
-                iterationCount ++;
-                if (iterationCount >= 5) {
-                    break;
-                }
-                GridXMin = GetGridX (Body.XMin);
-                GridXMax = GetGridX (Body.XMax);
-                GridYMin = GetGridY (Body.YMin);
-                GridYMax = GetGridY (Body.YMax);
-            }
-        }
-            
-		public static void PartitionObject (LSBody Body, bool gridBoundsCalculated = false) {
-            if (gridBoundsCalculated == false)
-            GetGridBounds (Body);
-
+		public static void PartitionObject (LSBody Body) {
+			GridXMin = ((Body.XMin - OffsetX) >> ShiftSize);
+			GridXMax = ((Body.XMax - OffsetX) >> ShiftSize);
+			GridYMin = ((Body.YMin - OffsetY) >> ShiftSize);
+			GridYMax = ((Body.YMax - OffsetY) >> ShiftSize);
 			Body.PastGridXMin = GridXMin;
 			Body.PastGridXMax = GridXMax;
 			Body.PastGridYMin = GridYMin;
 			Body.PastGridYMax = GridYMax;
-
-			for (int i = GridXMin; i <= GridXMax; i++) {
-				for (int j = GridYMin; j <= GridYMax; j++) {
-                    PartitionNode node = GetNode(i,j);
+			for (long i = GridXMin; i <= GridXMax; i++) {
+				for (long j = GridYMin; j <= GridYMax; j++) {
+					PartitionNode node = Nodes [i * Count + j];
 					node.Add (Body.ID);
 				}
 			}
 		}
-        /// <summary>
-        /// Returns true if size changed. False if not.
-        /// </summary>
-        /// <returns><c>true</c>, if size was checked, <c>false</c> otherwise.</returns>
-        /// <param name="gridXMin">Grid X minimum.</param>
-        /// <param name="gridXMax">Grid X max.</param>
-        /// <param name="gridYMin">Grid Y minimum.</param>
-        /// <param name="gridYMax">Grid Y max.</param>
-        private static bool CheckSize (int gridXMin, int gridXMax, int gridYMin, int gridYMax) {
-            if (GridXMin < 0 || GridXMax >= Nodes.Width || GridYMin < 0 || GridYMax >= Nodes.Height)
-            {
-                int boundXMin = Math.Min (GridXMin, 0) + BoundX;
-                int boundXMax = Math.Max (GridXMax + 1, Nodes.Width) + BoundX;
-                int boundYMin = Math.Min (GridYMin, 0) + BoundY;
-                int boundYMax = Math.Max (GridYMax + 1, Nodes.Height) + BoundY;
-
-                int newWidth = boundXMax - boundXMin;
-                int newHeight = boundYMax - boundYMin;
-
-                Nodes.Resize (newWidth, newHeight);
-                int xShift = BoundX - boundXMin;
-                int yShift = BoundY - boundYMin;
-                Nodes.Shift (xShift, yShift);
-
-                BoundX = boundXMin;
-                BoundY = boundYMin;
-
-                //Populating new array slots
-                //TODO: Optimize? Any clean way to do this? Worth it?
-                //DERP! Just allocate nodes as needed.
-
-                /*for (int i = Nodes.InnerArray.Length - 1; i >= 0; i--) {
-                    if (Nodes.InnerArray[i] == null)
-                        Nodes.InnerArray[i] = new PartitionNode();
-                }*/
-
-                return true;
-            }
-            return false;
-        }
-            
+
 		static int id1, id2;
 		static CollisionPair pair;
 
-        /// <summary>
-        /// World pos to partition index.
-        /// </summary>
-        /// <returns>The grid x.</returns>
-        /// <param name="xPos">X position.</param>
-        public static int GetGridX (long xPos) {
-            xPos += Offset;
-            return (int)((xPos) >> ShiftSize) - BoundX;
-        }
-        public static int GetGridY (long yPos) {
-            yPos += Offset;
-            return (int)((yPos) >> ShiftSize) - BoundY;
-        }
-        /// <summary>
-        /// World pos to relative position on grid.
-        /// </summary>
-        /// <returns>The relative x.</returns>
-        /// <param name="xPos">X position.</param>
-        public static long GetRelativeX (long xPos) {
-            return (xPos >> AdditionalShiftSize) - (FixedMath.Create(BoundX));
-        }
-        public static long GetRelativeY (long yPos) {
-            return (yPos >> AdditionalShiftSize) - (FixedMath.Create(BoundY));
-        }
-        /// <summary>
-        /// Index to world position.
-        /// </summary>
-        /// <returns>The world x.</returns>
-        /// <param name="gridX">Grid x.</param>
-        public static long GetWorldX (int gridX) {
-            return (FixedMath.Create(gridX + BoundX)) << AdditionalShiftSize;
-        }
-        public static long GetWorldY (int gridY) {
-            return (FixedMath.Create(gridY + BoundY)) << AdditionalShiftSize;
-        }
-        public static bool CheckValid (int indexX, int indexY) {
-            return indexX >= 0 && indexX < Nodes.Width && indexY >= 0 && indexY < Nodes.Height;
-        }
-        public static PartitionNode GetNode (int indexX, int indexY) {
-            PartitionNode node = Nodes[indexX,indexY];
-            if (node.IsNull ())
-            {
-                node = new PartitionNode();
-                Nodes[indexX,indexY] = node;
-            }
-            return node;
-        }
-
 		public static void CheckAndDistributeCollisions ()
 		{
 
diff --git a/Core/Simulation/Physics/Core/PartitionNode.cs b/Core/Simulation/Physics/Core/PartitionNode.cs
index e29762bb..927e278a 100644
--- a/Core/Simulation/Physics/Core/PartitionNode.cs
+++ b/Core/Simulation/Physics/Core/PartitionNode.cs
@@ -1,84 +1,64 @@
 using UnityEngine;
 using System.Collections;
 using System;
-
-namespace Lockstep
-{
-    public class PartitionNode
-    {
+namespace Lockstep {
+public class PartitionNode {
 		
-        public readonly FastList<int> ContainedObjects = new FastList<int>();
-
-        public int Count { get { return ContainedObjects.Count; } }
-
-        public int PeakCount { get { return ContainedObjects.Count; } }
-
-        public void Reset()
-        { 
-            ContainedObjects.FastClear();
-        }
-
-        int activationID;
-
-        public void Add(int item)
-        {
-            if (Count == 0)
-            {
-                activationID = Partition.ActivatedNodes.Add(this);
-            }
-            ContainedObjects.Add(item);
-        }
-
-        public void Remove(int item)
-        {
-            
-            if (ContainedObjects.Remove(item))
-            {
-                if (Count == 0)
-                {
-                    Partition.ActivatedNodes.RemoveAt(activationID);
-                    activationID = -1;
-                }
-            }
-        }
-
-        static int id1, id2;
-        static CollisionPair pair;
-
-        public void Distribute()
-        {
-            int nodePeakCount = PeakCount;
-            for (int j = 0; j < nodePeakCount; j++)
-            {
-                id1 = ContainedObjects [j];
-                for (int k = j + 1; k < nodePeakCount; k++)
-                {
-                    id2 = ContainedObjects [k];
-
+		public readonly FastBucket<int> ContainedObjects = new FastBucket<int> ();
+		public int Count {get {return ContainedObjects.Count;}}
+		public int PeakCount {get {return ContainedObjects.PeakCount;}}
+		public void Initialize () { 
+			ContainedObjects.FastClear ();
+		}
+		int activationID;
+		public void Add(int item)
+		{
+			if (Count == 0) {
+				activationID = Partition.ActivatedNodes.Add (this);
+			}
+			ContainedObjects.Add (item);
+		}
+		public void Remove(int item) {
+			if (ContainedObjects.Remove (item)) {
+				if (Count == 0) {
+					Partition.ActivatedNodes.RemoveAt (activationID);
+				}
+			}
+		}
 
-                    pair = PhysicsManager.GetCollisionPair(id1, id2);
-                    if (System.Object.ReferenceEquals(null, pair) == false && (pair.PartitionVersion != Partition._Version))
-                    {
-                        pair.CheckAndDistributeCollision();
-                        pair.PartitionVersion = Partition._Version;
-							
-                    }
-                }
-				
-            }
-        }
+		static int id1, id2;
+		static CollisionPair pair;
+		public void Distribute () {
+			int nodePeakCount = PeakCount;
+			for (int j = 0; j < nodePeakCount; j++) {
+				if (ContainedObjects.arrayAllocation[j])
+				{
+					id1 = this[j];
+					for (int k = j + 1; k < nodePeakCount; k++) {
+						if (ContainedObjects.arrayAllocation[k]) {
+							id2 = this [k];
+                            pair = PhysicsManager.GetCollisionPair(id1,id2);
+							if (System.Object.ReferenceEquals (null, pair) == false && (pair.PartitionVersion != Partition._Version)) {
+								pair.CheckAndDistributeCollision ();
+								pair.PartitionVersion = Partition._Version;
+							}
+						}
+					}
+				}
+			}
+		}
 
-        public int this [int index]
-        {
-            get
-            {
-                return ContainedObjects [index];
-            }
-            set
-            {
-                ContainedObjects [index] = value;
-            }
-        }
+		public int this[int index]
+		{
+			get
+			{
+				return ContainedObjects[index];
+			}
+			set
+			{
+				ContainedObjects[index] = value;
+			}
+		}
 
-    }
+	}
 }
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Core/PhysicsManager.cs b/Core/Simulation/Physics/Core/PhysicsManager.cs
index 1293694e..082d4fa4 100644
--- a/Core/Simulation/Physics/Core/PhysicsManager.cs
+++ b/Core/Simulation/Physics/Core/PhysicsManager.cs
@@ -15,40 +15,26 @@ namespace Lockstep
 {
     public static class PhysicsManager
     {
-
         #region User-defined Variables
 
         public const bool SimulatePhysics = true;
+        public const int SimulationSpread = 1;
 
-            
-        static double FixedDeltaTime
+        static	int VisualSetSpread
         {
             get
             {
-                return 1d / LockstepManager.FrameRate;
-            }
-        }
-
-        static int VisualSetSpread {
-            get {
                 return 2;
             }
         }
 
-        public static bool SettingsChanged { get; private set; }
-
-        private static PhysicsSettings _settings = new PhysicsSettings();
+        public const int FrameRate = LockstepManager.FrameRate / SimulationSpread;
 
-        public static PhysicsSettings Settings
+        static long FixedDeltaTicks
         {
             get
             {
-                return _settings;
-            }
-            set
-            {
-                _settings = value;
-                SettingsChanged = true;
+                return (long)((10000000L * VisualSetSpread) / FrameRate);
             }
         }
 
@@ -64,6 +50,8 @@ public static PhysicsSettings Settings
         public static LSBody[] SimObjects = new LSBody[MaxSimObjects];
         private static Dictionary<int,CollisionPair> CollisionPairs = new Dictionary<int,CollisionPair>(MaxSimObjects);
         public static FastList<CollisionPair> FastCollisionPairs = new FastList<CollisionPair>(MaxSimObjects);
+        private static int simulationCount;
+        private static int visualSetCount;
 
         #endregion
 
@@ -98,25 +86,30 @@ public static void Initialize()
 
             PeakCount = 0;
             AssimilatedCount = 0;
+            simulationCount = SimulationSpread;
 
             FastCollisionPairs.FastClear();
 
             Partition.Initialize();
-
-            if (SettingsChanged)
-            {
-                SettingsChanged = false;
-            }
         }
 
 
         public static void Simulate()
         {
+            simulationCount--;
+            if (simulationCount <= 0)
+            {
+                simulationCount = SimulationSpread;
+            } else
+            {
+                return;
+            }
+
+
             for (int i = 0; i < PeakCount; i++)
             {
                 if (SimObjectExists [i])
                 {
-
                     LSBody b1 = SimObjects [i];
                     b1.EarlySimulate();
                 }
@@ -130,14 +123,22 @@ public static void Simulate()
                     b1.Simulate();
                 }
             }
-            Simulated = true;
+
         }
 
         public static void LateSimulate()
         {
+            visualSetCount--;
 			
+            SetVisuals = visualSetCount <= 0;
 			
-
+            if (SetVisuals)
+            {
+                long curTicks = LockstepManager.Ticks;
+                LastDeltaTicks = curTicks - LastSimulateTicks;
+                LastSimulateTicks = curTicks;
+                visualSetCount = VisualSetSpread;
+            }
             for (int i = 0; i < PeakCount; i++)
             {
                 if (SimObjectExists [i])
@@ -148,26 +149,23 @@ public static void LateSimulate()
 
         }
 
-
-        public static float LerpTime { get ; private set; }
-        public static float ExtrapolationAmount {get; private set;}
-        public static float LerpDamping { get; private set; }
-
+        public static bool SetVisuals {get; private set;}
+        public static float LerpTime {get ;private set;}
+        public static float LerpDamping {get; private set;}
         private static float LerpDampScaler;
-
-        private static double LastTime { get; set; }
-
-        public static double AccumulatedTime { get; private set; }
-
-        public static bool Simulated { get; private set; }
+        static long LastSimulateTicks;
+        static long LastDeltaTicks;
 
         public static void Visualize()
         {
-            LerpDamping = 1f;
-            double curTime = LockstepManager.Seconds;
-            AccumulatedTime += (curTime - LastTime) * Time.timeScale;
-            LerpTime = (float)(AccumulatedTime / FixedDeltaTime);
-            if (LerpTime < 1f)
+            float smoothDeltaTime = Mathf.Max(Time.unscaledDeltaTime, 1f / 256);
+            LerpDampScaler = .3f / smoothDeltaTime;
+            LerpDamping = Time.unscaledDeltaTime * LerpDampScaler;
+            LerpDamping *= Time.timeScale;
+            long curTicks = LockstepManager.Ticks;
+            LerpTime = (float)((curTicks - LastSimulateTicks) / (double)FixedDeltaTicks);
+            LerpTime *= Time.timeScale;
+            if (LerpTime <= 1f)
             {
                 for (int i = 0; i < PeakCount; i++)
                 {
@@ -179,44 +177,14 @@ public static void Visualize()
                 }
             } else
             {
-                AccumulatedTime %= FixedDeltaTime;
-                ExtrapolationAmount = LerpTime;
-                LerpTime = (float)(AccumulatedTime / FixedDeltaTime);
-
-                if (Simulated)
+                for (int i = 0; i < PeakCount; i++)
                 {
-                    for (int i = 0; i < PeakCount; i++)
+                    if (SimObjectExists [i])
                     {
-                        if (SimObjectExists [i])
-                        {
-                            LSBody b1 = SimObjects [i];
-                            b1.LerpOverReset();
-
-                            b1.SetVisuals();
-
-                            b1.Visualize();
-
-
-                        }
-                    }
-                    Simulated = false;
-                }
-                else {
-                    for (int i = 0; i < PeakCount; i++) {
-                        if (SimObjectExists[i]) {
-                            LSBody b1 = SimObjects[i];
-
-                            b1.LerpOverReset();
-                            b1.SetExtrapolatedVisuals();
-
-                            b1.Visualize();
-
-                        }
+                        SimObjects [i].LerpOverReset();
                     }
                 }
-
             }
-            LastTime = curTime;
         }
 
         public static float ElapsedTime;
@@ -245,7 +213,7 @@ internal static int Assimilate(LSBody body)
 
         private static CollisionPair CreatePair(LSBody body1, LSBody body2)
         {
-            int pairIndex = GetCollisionPairIndex(body1.ID, body2.ID);
+            int pairIndex = GetCollisionPairIndex (body1.ID,body2.ID);
             CollisionPair pair = new CollisionPair();
             CollisionPairs [pairIndex] = pair;
             FastCollisionPairs.Add(pair);
diff --git a/Core/Simulation/Physics/Core/Settings.meta b/Core/Simulation/Physics/Core/Settings.meta
deleted file mode 100644
index d50f79c5..00000000
--- a/Core/Simulation/Physics/Core/Settings.meta
+++ /dev/null
@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: d1d0be0a5b6fd46f0949436686f2e114
-folderAsset: yes
-timeCreated: 1450914524
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs b/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs
deleted file mode 100644
index b003c0a7..00000000
--- a/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using UnityEngine;
-using System.Collections;
-
-namespace Lockstep
-{
-    public sealed class PhysicsSettings
-    {
-        public PhysicsSettings () {
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs.meta b/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs.meta
deleted file mode 100644
index 1144da6b..00000000
--- a/Core/Simulation/Physics/Core/Settings/PhysicsSettings.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 3d247f751573d47dca57fe02e90cc409
-timeCreated: 1450914529
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Extra.meta b/Core/Simulation/Physics/Extra.meta
new file mode 100644
index 00000000..aa1e2d12
--- /dev/null
+++ b/Core/Simulation/Physics/Extra.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b3dd3b0115cc8424c9e32bb0b9588a45
+folderAsset: yes
+timeCreated: 1436507116
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Extra/Raycaster.cs b/Core/Simulation/Physics/Extra/Raycaster.cs
new file mode 100644
index 00000000..5d32333a
--- /dev/null
+++ b/Core/Simulation/Physics/Extra/Raycaster.cs
@@ -0,0 +1,197 @@
+using UnityEngine;
+using System.Collections;
+
+namespace Lockstep
+{
+	public class Raycaster
+	{
+		public static uint _Version = 1;
+		public LSBody Hit;
+		public FastList<LSBody> Hits = new FastList<LSBody> ();
+		public FastList<Vector2d> HitPoints = new FastList<Vector2d> ();
+
+		#region Method Variables
+		static int i, j;
+		static long x0, y0, x1, y1;
+		static long dx, dy, error, ystep, x, y, t;
+		static long compare1, compare2;
+		static long retX, retY;
+		static bool steep;
+		static long SwapValue;
+
+		static bool DidHit;
+		static bool MadeContact;
+		static long Projection, TestMin, TestMax;
+		static long Mag, AxisX, AxisY, AxisMin, AxisMax, PerpProj;
+		static long XMin, XMax, YMin, YMax;
+		#endregion
+
+
+		public bool RaycastAll (Vector2d From, Vector2d To, int ExceptionID)
+		{
+			return InternalRaycast (From,To,ExceptionID);
+		}
+		private bool InternalRaycast (Vector2d From, Vector2d To, int ExceptionID)
+		{
+			_Version++;
+
+			MadeContact = false;
+			Hits.FastClear ();
+
+			
+			const int StepSize = 1 << Partition.ShiftSize;
+			x0 = From.x;
+			y0 = From.y;
+			x1 = To.x;
+			y1 = To.y;
+			if (y1 > y0)
+				compare1 = y1 - y0;
+			else
+				compare1 = y0 - y1;
+			if (x1 > x0)
+				compare2 = x1 - x0;
+			else
+				compare2 = x0 - x1;
+			steep = compare1 > compare2;
+			if (steep) {
+				t = x0; // swap x0 and y0
+				x0 = y0;
+				y0 = t;
+				t = x1; // swap x1 and y1
+				x1 = y1;
+				y1 = t;
+			}
+			if (x0 > x1) {
+				t = x0; // swap x0 and x1
+				x0 = x1;
+				x1 = t;
+				t = y0; // swap y0 and y1
+				y0 = y1;
+				y1 = t;
+			}
+			dx = x1 - x0;
+			
+			dy = (y1 - y0);
+			if (dy < 0)
+				dy = -dy;
+			
+			error = dx / 2;
+			ystep = (y0 < y1) ? StepSize : -StepSize;
+			y = y0;
+			
+			AxisX = From.x - To.x;
+			AxisY = From.y - To.y;
+			Mag = FixedMath.Sqrt ((AxisX * AxisX + AxisY * AxisY) >> FixedMath.SHIFT_AMOUNT);
+			if (Mag == 0)
+				return false;
+			AxisX = FixedMath.Div (AxisX, Mag);
+			AxisY = FixedMath.Div (AxisY, Mag);
+			AxisMin = Vector2d.Dot (AxisX, AxisY, From.x, From.y);
+			AxisMax = Vector2d.Dot (AxisX, AxisY, To.x, To.y);
+			if (AxisMin > AxisMax)
+			{
+				SwapValue = AxisMin;
+				AxisMin = AxisMax;
+				AxisMax = SwapValue;
+			}
+			PerpProj = Vector2d.Dot (-AxisY, AxisX, From.x, From.y);
+
+			XMin = From.x;
+			XMax = To.x;
+			if (XMin > XMax)
+			{
+				SwapValue = XMin;
+				XMin = XMax;
+				XMax = SwapValue;
+			}
+			YMin = From.y;
+			YMax = To.y;
+			if (YMin > YMax)
+			{
+				SwapValue = YMin;
+				YMin = YMax;
+				YMax = SwapValue;
+			}
+			x = x0;
+			while (true) {
+				if (steep)
+				{
+					retX = (y - Partition.OffsetX) / StepSize;
+					retY = (x - Partition.OffsetY) / StepSize;
+				}
+				else {
+					retX = (x - Partition.OffsetX) / StepSize;
+					retY = (y - Partition.OffsetY) / StepSize;
+				}
+				
+				PartitionNode node = Partition.Nodes [retX * Partition.Count + retY];
+				if (node.Count > 0) {
+					
+					for (i = 0; i < node.Count; i++) {
+
+						DidHit = false;
+
+						LSBody body = PhysicsManager.SimObjects [node [i]];
+						if (body.RaycastVersion != _Version && body.ID != ExceptionID) {
+							body.RaycastVersion = _Version;
+							switch (body.Shape) {
+							case ColliderType.Circle:
+								Projection = Vector2d.Dot (AxisX, AxisY, body._position.x, body._position.y);
+								TestMin = Projection - body.Radius;
+								TestMax = Projection + body.Radius;
+								if (TestMin < AxisMax) {
+									if (TestMax > AxisMin) {
+										Projection = Vector2d.Dot (-AxisY, AxisX, body._position.x, body._position.y);
+										TestMin = Projection - body.Radius;
+										TestMax = Projection + body.Radius;
+										if (PerpProj < TestMax && PerpProj > TestMin) {
+											DidHit = true;
+										}
+									}
+								}
+								break;
+								
+							case ColliderType.AABox:
+								if (AxisMin < body.XMax) {
+									if (AxisMax > body.XMin) {
+										if (PerpProj < body.YMax) {
+											if (PerpProj > body.YMin) {
+
+												DidHit = true;
+											}
+										}
+									}
+								}
+								break;
+							}
+							if (DidHit) {
+								Hits.Add (body);
+								MadeContact = true;
+								break;
+							}
+						}
+					}
+
+				}
+
+				error = error - dy;
+				if (error < 0) {
+					y += ystep;
+					error += dx;
+				}
+
+				if (x >= x1)
+				{
+					break;
+				}
+				x += StepSize;
+
+			}
+			return MadeContact;
+		}
+
+
+
+
+	}
+}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Raycast/Raycaster.cs.meta b/Core/Simulation/Physics/Extra/Raycaster.cs.meta
similarity index 69%
rename from Core/Simulation/Physics/Raycast/Raycaster.cs.meta
rename to Core/Simulation/Physics/Extra/Raycaster.cs.meta
index c1406436..4a8e60dd 100644
--- a/Core/Simulation/Physics/Raycast/Raycaster.cs.meta
+++ b/Core/Simulation/Physics/Extra/Raycaster.cs.meta
@@ -1,7 +1,7 @@
 fileFormatVersion: 2
-guid: c0518fb1c2c1e43a189c9681797d5098
-timeCreated: 1450907232
-licenseType: Pro
+guid: eaa9eb0f0ca5c4757bf1f81c35373c42
+timeCreated: 1436507144
+licenseType: Free
 MonoImporter:
   serializedVersion: 2
   defaultReferences: []
diff --git a/Core/Simulation/Physics/Raycast.meta b/Core/Simulation/Physics/Raycast.meta
deleted file mode 100644
index a7bd55fd..00000000
--- a/Core/Simulation/Physics/Raycast.meta
+++ /dev/null
@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: 377cd847965ac4626a70b614068acad0
-folderAsset: yes
-timeCreated: 1450907224
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Raycast/Raycaster.cs b/Core/Simulation/Physics/Raycast/Raycaster.cs
deleted file mode 100644
index 352511b0..00000000
--- a/Core/Simulation/Physics/Raycast/Raycaster.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using System.Collections.Generic;
-using PanLineAlgorithm;
-
-namespace Lockstep
-{
-
-    public static class Raycaster
-    {
-        public static IEnumerable<LSBody> RaycastAll(Vector2d start, Vector2d end)
-        {
-            LSBody.PrepareAxisCheck(start, end);
-            foreach (FractionalLineAlgorithm.Coordinate coor in
-                GetRelevantNodeCoordinates (start,end))
-            {
-                int indexX = coor.X;
-                int indexY = coor.Y;
-                if (!Partition.CheckValid(coor.X, coor.Y))
-                {
-                    break;
-                }
-                PartitionNode node = Partition.GetNode(indexX, indexY);
-                for (int i = node.ContainedObjects.Count - 1; i >= 0; i--)
-                {
-                    LSBody body = PhysicsManager.SimObjects [node.ContainedObjects [i]];
-                    if (body.Overlaps())
-                        yield return body;
-                    
-                }
-            }
-            yield break;
-        }
-
-        public static IEnumerable<LSBody> RaycastAll(Vector2d start, Vector2d end, long startHeight, long heightSlope)
-        {
-            foreach (LSBody body in RaycastAll(start,end))
-            {
-                long dist = body.GetClosestDist(start);
-                long heightAtBodyPosition = startHeight + (dist.Mul(heightSlope));
-                if (body.HeightOverlaps(heightAtBodyPosition))
-                {
-                    yield return body;
-                }
-            }
-        }
-
-        public static IEnumerable<FractionalLineAlgorithm.Coordinate> GetRelevantNodeCoordinates(Vector2d start, Vector2d end)
-        {
-            //Note: 99% sure this is deterministic enough for use in simulation.
-            foreach (FractionalLineAlgorithm.Coordinate coor in FractionalLineAlgorithm.Trace(
-                Partition.GetRelativeX(start.x).ToDouble(),
-                Partition.GetRelativeX(start.y).ToDouble(),
-                Partition.GetRelativeY(end.x).ToDouble(),
-                Partition.GetRelativeY(end.y).ToDouble()))
-            {
-                int indexX = coor.X;
-                int indexY = coor.Y;
-                yield return coor;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Raycast/Test.meta b/Core/Simulation/Physics/Raycast/Test.meta
deleted file mode 100644
index dbef4372..00000000
--- a/Core/Simulation/Physics/Raycast/Test.meta
+++ /dev/null
@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: 5ca9f294c342347e98a0078969238eed
-folderAsset: yes
-timeCreated: 1451100351
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs b/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs
deleted file mode 100644
index 0ec8ba4c..00000000
--- a/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using PanLineAlgorithm;
-using CCoordinate = PanLineAlgorithm.FractionalLineAlgorithm.Coordinate;
-namespace Lockstep.Test
-{
-    public class RaycastTestHelper : MonoBehaviour
-    {
-        public bool testPartitions = true;
-        public bool testBodies = true;
-        public Transform start;
-        public Transform end;
-        Vector2d startPos;
-        Vector2d endPos;
-        void OnDrawGizmos () {
-             startPos = new Vector2d(start.position);
-             endPos = new Vector2d(end.position);
-            if (testPartitions)TestPartitions ();
-            if (testBodies)TestBodies ();
-            Gizmos.DrawLine(startPos.ToVector3(0),endPos.ToVector3(0));
-        }
-        FastList<LSBody> lastBodies = new FastList<LSBody>();
-        void TestBodies () {
-            if (Application.isPlaying == false) return;
-            for (int i = 0; i < lastBodies.Count; i++) {
-                lastBodies[i].GetComponentInChildren<Renderer>().material.color = Color.white;
-            }
-            lastBodies.FastClear();
-            foreach (LSBody body in Raycaster.RaycastAll (startPos, endPos)) {
-                body.GetComponentInChildren<Renderer>().material.color = Color.red;
-                lastBodies.Add(body);
-            }
-        }
-        void TestPartitions () {
-            int width = Partition.Nodes.Width;
-            int height = Partition.Nodes.Height;
-            bool[,] casted = new bool[width,height];
-
-            foreach (CCoordinate coor in Raycaster.GetRelevantNodeCoordinates (startPos,endPos)) {
-                if (Partition.CheckValid(coor.X,coor.Y))
-                    casted[coor.X,coor.Y] = true;
-            }
-
-            Vector3 size = new Vector3(1 << Partition.AdditionalShiftSize, .1f, 1 << Partition.AdditionalShiftSize);
-            for (int i = 0; i < width; i++) {
-                for (int j = 0; j < height; j++) {
-                    if (casted[i,j])
-                        Gizmos.color = Color.red;
-                    else
-                        Gizmos.color = Color.green;
-                    Vector3 drawPos = new Vector2d (Partition.GetWorldX(i), Partition.GetWorldY(j)).ToVector3(0);
-                    Gizmos.DrawCube (drawPos, size);
-                    Gizmos.color = Color.black;
-                    Gizmos.DrawWireCube(drawPos,size);
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs.meta b/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs.meta
deleted file mode 100644
index 56048a19..00000000
--- a/Core/Simulation/Physics/Raycast/Test/RaycastTestHelper.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: ab96a25659afa4c24936517b33c26158
-timeCreated: 1451100493
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity b/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity
deleted file mode 100644
index 3794a0ee..00000000
Binary files a/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity and /dev/null differ
diff --git a/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity.meta b/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity.meta
deleted file mode 100644
index 0348828e..00000000
--- a/Core/Simulation/Physics/Raycast/Test/RaycastTestScene.unity.meta
+++ /dev/null
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 1d4f0a7431edf485d85fd136716684eb
-timeCreated: 1451100363
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Utility/Array2D.cs b/Core/Utility/Array2D.cs
index 0a4e516b..c837b348 100644
--- a/Core/Utility/Array2D.cs
+++ b/Core/Utility/Array2D.cs
@@ -1,170 +1,98 @@
 using System;
 using UnityEngine;
+namespace Lockstep {
+//Note: Not Serializable - Unity can't serialize generics
+public class Array2D<T>{
+	[SerializeField]
+	private int _width = 0;
+	public int Width {
+		get {
+			return _width;
+		}
+		set {
+			if (_width != value)
+			{
+				if (StartVal .IsNotNull () && StartVal.GetType () == typeof (bool))
+				{
+				bool test = (bool)(object)StartVal;
+				}
+				int newWidth = value;
+				T[] newArray = new T[newWidth * _height];
+				for (int i = 0; i < _height; i++)
+				{
+					int rowIndex = i * newWidth;
+					Array.Copy (_innerArray, i * _width, newArray, rowIndex, _width < newWidth ? _width : newWidth);
+					if (_width < newWidth)
+					{
+						int fillStart = rowIndex + _width - 1;
+						if (fillStart < 0) fillStart = 0;
+						int fillEnd = rowIndex + newWidth;
+
+						for (int j = fillStart; j < fillEnd; j++)
+						{
+							newArray[j] = StartVal;
+						}
+					}
+				}
+				_innerArray = newArray;
+				_width = newWidth;
+			}
+		}
+	}
+	[SerializeField]
+	public int _height = 0;
+	public int Height {
+		get {
+			return _height;
+		}
+		set {
+			if (_height != value) {
+				int newHeight = value;
+				Array.Resize <T>(ref _innerArray, newHeight * _width);
+				for (int i = _height * _width; i < _innerArray.Length; i++)
+				{
+					_innerArray[i] = StartVal;
+				}
+				_height = newHeight;
+			}
+		}
+	}
+	[SerializeField]
+	private T[] _innerArray = new T[0];
+
+	public T[] InnerArray {get {return _innerArray;}}
+
+	private T StartVal;
+
+	public Array2D (int width, int height, T startVal) : this (width,height) {
+		StartVal = startVal;
+	}
+	public Array2D (int width, int height) {
+		_innerArray = new T[width * height];
+		_width = width;
+		_height = height;
+	}
+
+	public T this [int w, int h] {
+		get {
+			int index = GetIndex (w,h);
+			return _innerArray[index];
+		}
+		set {
+			int index = GetIndex (w,h);
+			_innerArray[index] = value;
+		}
+	}
+
+	private int GetIndex (int w, int h) {
+		return w + h * Width;
+	}
 
-namespace Lockstep
-{
-    //Note: Not Serializable - Unity can't serialize generics
-    /// <summary>
-    /// Flattened 2D array wrapper with dynamic resizing.
-    /// </summary>
-    public class Array2D<T>
-    {
-        [SerializeField]
-        private int _width = 0;
-
-        public int Width
-        {
-            get
-            {
-                return _width;
-            }
-        }
-
-        [SerializeField]
-        public int _height = 0;
-
-        public int Height
-        {
-            get
-            {
-                return _height;
-            }
-        }
-
-        [SerializeField]
-        private T[] _innerArray = new T[0];
-
-        public T[] InnerArray { get { return _innerArray; } }
-
-        private T StartVal;
-
-        public Array2D(int width, int height, T startVal) : this(width, height)
-        {
-            StartVal = startVal;
-        }
-
-        public Array2D(int width, int height)
-        {
-            _innerArray = new T[width * height];
-            _width = width;
-            _height = height;
-        }
-
-        public T this [int w, int h]
-        {
-            get
-            {
-                int index = GetIndex(w, h);
-                try {
-                return _innerArray [index];
-                }
-                catch {
-                    throw new System.IndexOutOfRangeException(w + ", " + h);
-                }
-            }
-            set
-            {
-                try {
-                int index = GetIndex(w, h);
-                _innerArray [index] = value;
-                }
-                catch {
-                    throw new System.IndexOutOfRangeException(w + ", " + h);
-                }
-            }
-        }
-
-
-        public void Resize(int newWidth, int newHeight)
-        {
-            if (_height != newHeight || _width != newWidth)
-            {
-                //Height changes require remapping
-                T[] newArray = new T[newWidth * newHeight];
-
-                for (int i = _width - 1; i >= 0; i--)
-                {
-                    Array.Copy(_innerArray, i * _height, newArray, i * newHeight, Math.Min(_height, newHeight));
-                }
-
-                _innerArray = newArray;
-
-                _height = newHeight;
-                _width = newWidth;
-            }
-        }
-
-        public void Shift(int xShift, int yShift)
-        {
-            if (yShift != 0)
-            {
-                int absShift = Math.Abs(yShift);
-  
-                int shiftLength = _height - absShift;
-                if (shiftLength < 0)
-                {
-                    //If the shift is more than the array's height, clear all elements
-                    Array.Clear(_innerArray,0,_innerArray.Length);
-                }
-                else {
-                    T[] newArray = new T[_innerArray.Length];
-
-                    for (int i = _width - 1; i >= 0; i--) {
-                        int index = i * _height;
-                        int newIndex = index + yShift;
-                        if (yShift < 0)
-                        {
-                            index -= yShift;
-                            newIndex -= yShift;
-                        }
-                        Array.Copy(_innerArray,index,newArray,newIndex,shiftLength);
-                    }
-                    _innerArray = newArray;
-                }
-            }
-            if (xShift != 0) {
-
-                int absShift = Math.Abs(xShift);
-                if (absShift >= _width)
-                {
-                    //If the shift is more than the array's height, clear all elements
-                    Array.Clear(_innerArray,0,_innerArray.Length);
-                }
-                else {
-                    T[] newArray = new T[_innerArray.Length];
-                    int start = 0;
-                    int end = _width;
-                    if (xShift < 0)
-                        start -= xShift;
-                    else
-                        end -= xShift;
-                    for (int i = start; i < end; i++) {
-                        int index = i * _height;
-                        int newIndex = (i + xShift) * _height;
-                        Array.Copy (_innerArray, index, newArray, newIndex, _height);
-                    }
-                    _innerArray = newArray;
-                }
-            }
-        }
-
-        public void Clear () {
-            Array.Clear (_innerArray, 0, _innerArray.Length);
-        }
-
-        private int GetIndex(int w, int h)
-        {
-            return w * this._height + h;
-        }
-
-    }
-
-    [Serializable]
-    public class BoolArray2D : Array2D<bool>
-    {
-        public BoolArray2D(int i, int j, bool startVal) : base(i, j, startVal)
-        {
+}
+[Serializable]
+public class BoolArray2D : Array2D<bool>{
+	public BoolArray2D (int i, int j, bool startVal) : base(i,j, startVal) {
 
-        }
-    }
+	}
+}
 }
diff --git a/Core/Utility/Fast/BiDictionary.cs b/Core/Utility/Fast/BiDictionary.cs
deleted file mode 100644
index 15c3c917..00000000
--- a/Core/Utility/Fast/BiDictionary.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace Lockstep
-{
-    public class BiDictionary<T1,T2> : Dictionary<T1,T2>
-    {
-        private Dictionary<T2,T1> _reverseMap = new Dictionary<T2, T1>();
-        public void Add (T1 item1, T2 item2) {
-            base.Add(item1,item2);
-            _reverseMap.Add(item2,item1);
-        }
-        public void Remove (T1 item1, T2 item2) {
-            base.Remove(item1);
-            _reverseMap.Remove (item2);
-        }
-
-        public T1 GetReversed (T2 key) {
-            return _reverseMap[key];
-        }
-        public bool TryGetValueReversed (T2 key, out T1 value) {
-            return _reverseMap.TryGetValue(key,out value);
-        }
-    }
-}
\ No newline at end of file
diff --git a/Core/Utility/Fast/BiDictionary.cs.meta b/Core/Utility/Fast/BiDictionary.cs.meta
deleted file mode 100644
index 8aa07586..00000000
--- a/Core/Utility/Fast/BiDictionary.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 41ae91841d2204adda1f44392b3209df
-timeCreated: 1451430327
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Utility/Fast/FastList.cs b/Core/Utility/Fast/FastList.cs
index 60f8a39d..462869bc 100644
--- a/Core/Utility/Fast/FastList.cs
+++ b/Core/Utility/Fast/FastList.cs
@@ -83,15 +83,13 @@ public void AddRange (T[] items, int startIndex, int count)
 			}
 		}
 
-		public bool Remove (T item)
+		public void Remove (T item)
 		{
 			
 			int index = Array.IndexOf (innerArray, item, 0, Count);
 			if (index >= 0) {
 				RemoveAt (index);
-                return true;
 			}
-            return false;
 		}
 
 		public void RemoveAt (int index)
diff --git a/Core/Utility/Fast/Tests.meta b/Core/Utility/Fast/Tests.meta
deleted file mode 100644
index 1acfb859..00000000
--- a/Core/Utility/Fast/Tests.meta
+++ /dev/null
@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: e4c91985e91b64f2ab89019d78f96413
-folderAsset: yes
-timeCreated: 1450911835
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Utility/Fast/Tests/Array2DTester.cs b/Core/Utility/Fast/Tests/Array2DTester.cs
deleted file mode 100644
index 6137128a..00000000
--- a/Core/Utility/Fast/Tests/Array2DTester.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using UnityEngine;
-using System.Collections;
-using Lockstep;
-
-public class Array2DTester : MonoBehaviour
-{
-    Array2D<Coordinate> testArray;
-    int shiftAmount = 1;
-    // Use this for initialization
-    void Start()
-    {
-        testArray = new Array2D<Coordinate>(4, 4);
-        Refill ();
-    }
-
-    void Refill () {
-        for (int i= 0 ; i < testArray.Width; i++) {
-            for (int j = 0; j < testArray.Height; j++) {
-                testArray[i,j] = new Coordinate(i,j);
-            }
-        }
-    }
-
-    void OnGUI()
-    {
-        GUILayout.BeginHorizontal();
-        for (int i = 0; i < testArray.Width; i++)
-        {
-            GUILayout.BeginVertical();
-            for (int j = testArray.Height - 1; j >= 0; j--)
-            {
-                GUILayout.Label(testArray [i, j].ToString(), GUILayout.Height(50f), GUILayout.Width(50));
-            }
-            GUILayout.EndVertical();
-        }
-        GUILayout.EndHorizontal();
-        if (GUILayout.Button("Refill")) {
-            Refill ();
-        }
-
-        int.TryParse(GUILayout.TextField(shiftAmount.ToString()), out shiftAmount);
-        if (GUILayout.Button ("Shift Width")) {
-            testArray.Shift (shiftAmount, 0);
-        }
-        if (GUILayout.Button("Shift Height")) {
-            testArray.Shift (0,shiftAmount);
-        }
-    }
-}
diff --git a/Core/Utility/Fast/Tests/Array2DTester.cs.meta b/Core/Utility/Fast/Tests/Array2DTester.cs.meta
deleted file mode 100644
index d88819ad..00000000
--- a/Core/Utility/Fast/Tests/Array2DTester.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 511b38cdc246a4d6c875c8f19adbf926
-timeCreated: 1450911903
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Core/Simulation/Physics/Core/Editor.meta b/Core/Utility/MessageSystem/Editor.meta
similarity index 67%
rename from Core/Simulation/Physics/Core/Editor.meta
rename to Core/Utility/MessageSystem/Editor.meta
index 3ae0977b..15e5a0d2 100644
--- a/Core/Simulation/Physics/Core/Editor.meta
+++ b/Core/Utility/MessageSystem/Editor.meta
@@ -1,7 +1,7 @@
 fileFormatVersion: 2
-guid: 9a122c7608a3c4f509daa4f384619ffa
+guid: 25786b64018524328ac069428e4b67dc
 folderAsset: yes
-timeCreated: 1450833968
+timeCreated: 1449883316
 licenseType: Pro
 DefaultImporter:
   userData: 
diff --git a/Core/Utility/Serialization/Writer.cs b/Core/Utility/Serialization/Writer.cs
index 24bd92fa..61fddef4 100644
--- a/Core/Utility/Serialization/Writer.cs
+++ b/Core/Utility/Serialization/Writer.cs
@@ -71,8 +71,5 @@ public void WriteByteArray (byte[] byteArray) {
             canvas.AddRange(byteArray);
         }
 
-        public void Reset () {
-            this.canvas.FastClear();
-        }
 	}
 }
\ No newline at end of file
diff --git a/Database/Editor/DataHelper.cs b/Database/Editor/DataHelper.cs
index 47c9d90a..4fef6d17 100644
--- a/Database/Editor/DataHelper.cs
+++ b/Database/Editor/DataHelper.cs
@@ -6,7 +6,7 @@
 using UnityEditor;
 using Lockstep;
 using System.Reflection;
-using Lockstep.Rotorz.ReorderableList;
+using Rotorz.ReorderableList;
 namespace Lockstep.Data
 {
 
diff --git a/Database/Scripts/DataItem.cs b/Database/Scripts/DataItem.cs
index 6f5c1e46..cea514f0 100644
--- a/Database/Scripts/DataItem.cs
+++ b/Database/Scripts/DataItem.cs
@@ -8,9 +8,6 @@ namespace Lockstep.Data
     [System.Serializable]
     public class DataItem
     {
-        public DataItem (string name) {
-            _name = name;
-        }
         public DataItem() {}
 
         [SerializeField]
diff --git a/Database/Scripts/DataItemAttribute.cs b/Database/Scripts/DataItemAttribute.cs
index 4f9ccab5..90096b3a 100644
--- a/Database/Scripts/DataItemAttribute.cs
+++ b/Database/Scripts/DataItemAttribute.cs
@@ -1,5 +1,5 @@
 #if UNITY_EDITOR
-using Lockstep.Rotorz.ReorderableList;
+using Rotorz.ReorderableList;
 #endif
 using System;
 
diff --git a/Database/Scripts/DataItemTemplates/InputDataItem.cs b/Database/Scripts/DataItemTemplates/InputDataItem.cs
deleted file mode 100644
index ab623cb0..00000000
--- a/Database/Scripts/DataItemTemplates/InputDataItem.cs
+++ /dev/null
@@ -1,16 +0,0 @@
- using UnityEngine;
-using System.Collections;
-
-namespace Lockstep.Data
-{
-    [System.Serializable]
-    public class InputDataItem : DataItem
-    {
-        public InputDataItem (string name) {
-            _name = name;
-        }
-        public InputDataItem (string name, KeyCode keyCode) {
-            _name = name;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Database/Scripts/DataItemTemplates/InputDataItem.cs.meta b/Database/Scripts/DataItemTemplates/InputDataItem.cs.meta
deleted file mode 100644
index b42e2de8..00000000
--- a/Database/Scripts/DataItemTemplates/InputDataItem.cs.meta
+++ /dev/null
@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: d0d57c575705a484d9228bec7d27254f
-timeCreated: 1451428226
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Database/Scripts/DefaultLSDatabase.cs b/Database/Scripts/DefaultLSDatabase.cs
index d2342f74..70ddacc4 100644
--- a/Database/Scripts/DefaultLSDatabase.cs
+++ b/Database/Scripts/DefaultLSDatabase.cs
@@ -31,26 +31,6 @@ protected AgentInterfacer[]
 
         #endregion
 
-        #region Input
-        [SerializeField]
-        [RegisterData ("Input")]
-        private InputDataItem[] _inputData = new InputDataItem[] {
-            new InputDataItem("Special1", KeyCode.Q),
-            new InputDataItem("Special2", KeyCode.W),
-            new InputDataItem("Special3", KeyCode.E),
-            new InputDataItem("Special4", KeyCode.R),
-            new InputDataItem("Core1", KeyCode.A),
-            new InputDataItem("Core2", KeyCode.S),
-            new InputDataItem("Core3", KeyCode.D),
-            new InputDataItem("Core4",KeyCode.F),
-            new InputDataItem("Item1", KeyCode.Z),
-            new InputDataItem("Item2",KeyCode.X),
-            new InputDataItem("Item3",KeyCode.C),
-            new InputDataItem("Item4",KeyCode.V)
-        };
-        public InputDataItem[] InputData {get {return _inputData;}}
-        #endregion
-
         #region Projectiles
 
         [SerializeField,RegisterData("Projectiles")]
diff --git a/Example/ExampleDatabase/Example_Database.asset b/Example/ExampleDatabase/Example_Database.asset
index e2bca54d..d80aa466 100644
Binary files a/Example/ExampleDatabase/Example_Database.asset and b/Example/ExampleDatabase/Example_Database.asset differ
diff --git a/Example/ExampleGameManager.cs b/Example/ExampleGameManager.cs
index f835fc13..7f705096 100644
--- a/Example/ExampleGameManager.cs
+++ b/Example/ExampleGameManager.cs
@@ -11,6 +11,8 @@ public class ExampleGameManager : GameManager {
         [SerializeField]
         private int _spawnAmount;
 
+        private NetworkHelper _mainNetworkHelper = new ExampleNetworkHelper ();
+
         protected FastList<LSAgent> spawnedAgents = new FastList<LSAgent>();
 
         public override void GetBehaviourHelpers (FastList<BehaviourHelper> output) {
@@ -19,13 +21,18 @@ public override void GetBehaviourHelpers (FastList<BehaviourHelper> output) {
 
         }
 
+        public override NetworkHelper MainNetworkHelper {
+            get {
+                return _mainNetworkHelper;
+            }
+        }
 
 
-        protected override void OnGameStart () {
-            AgentController ac = AgentController.Create();
-            PlayerManager.AddController (ac);
+        protected override void OnStartGame () {
+            AgentController ac = new AgentController();
 
             for (int i = 0; i < _spawnAmount; i++) {
+                PlayerManager.AddController (ac);
                 spawnedAgents.Add (ac.CreateAgent (_spawnCode,Vector2d.zero));
             }
         }
diff --git a/Example/ExampleNetworkHelper.cs b/Example/ExampleNetworkHelper.cs
index fa27eb56..bb23d209 100644
--- a/Example/ExampleNetworkHelper.cs
+++ b/Example/ExampleNetworkHelper.cs
@@ -1,7 +1,7 @@
 using UnityEngine;
 using System.Collections;
 
-namespace Lockstep.NetworkHelpers {
+namespace Lockstep.Example {
     public class ExampleNetworkHelper : NetworkHelper {
         public override void Connect (string ip) {
 
@@ -12,7 +12,7 @@ public override void Disconnect () {
         public override void Host (int roomSize) {
 
         }
-        public override int ID {
+        public override ushort ID {
             get {
                 return 0;
             }
@@ -32,10 +32,11 @@ public override int PlayerCount {
                 return 1;
             }
         }
-        protected override void OnSendMessageToAll(MessageType messageType, byte[] data)
-        {
-            base.OnSendMessageToAll(messageType,data);
+        public override void SendMessageToAll (MessageType messageType, byte[] data) {
+            base.Receive (messageType, data);
+        }
+        public override void SendMessageToServer (MessageType messageType, byte[] data) {
+            base.Receive (messageType, data);
         }
-
     }
 }
\ No newline at end of file
diff --git a/Example/ExampleScene.unity b/Example/ExampleScene.unity
index 30724348..cacc99af 100644
Binary files a/Example/ExampleScene.unity and b/Example/ExampleScene.unity differ
diff --git a/Example/Manager.prefab b/Example/Manager.prefab
index 6ef81489..4f251e12 100644
Binary files a/Example/Manager.prefab and b/Example/Manager.prefab differ
diff --git a/Example/TestAgent.prefab b/Example/TestAgent.prefab
index e31cf8a5..57b7c9be 100644
Binary files a/Example/TestAgent.prefab and b/Example/TestAgent.prefab differ
diff --git a/Core/Game/Player/Commands.meta b/Integration/Editor/Database.meta
similarity index 67%
rename from Core/Game/Player/Commands.meta
rename to Integration/Editor/Database.meta
index c2b99586..b1066284 100644
--- a/Core/Game/Player/Commands.meta
+++ b/Integration/Editor/Database.meta
@@ -1,7 +1,7 @@
 fileFormatVersion: 2
-guid: 4dc29c294927c4f7ea44f31559a4b98c
+guid: cecd0bacae0864fc4b77fd02d5240393
 folderAsset: yes
-timeCreated: 1451622230
+timeCreated: 1448496893
 licenseType: Pro
 DefaultImporter:
   userData: 
diff --git a/Integration/Editor/LSBodyEditor.cs b/Integration/Editor/LSBodyEditor.cs
new file mode 100644
index 00000000..61780e09
--- /dev/null
+++ b/Integration/Editor/LSBodyEditor.cs
@@ -0,0 +1,264 @@
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Lockstep.Integration
+{
+    [CustomEditor(typeof(LSBody))]//, CanEditMultipleObjects]
+	public class LSBodyEditor : Editor
+    {
+        public static Color MoveColor = Color.yellow;
+        public static Color FrameColor = Color.blue;
+
+        public override void OnInspectorGUI()
+        {
+            if (Application.isPlaying)
+            {
+                EditorGUILayout.LabelField("Debug Information", EditorStyles.boldLabel);
+				
+                base.DrawDefaultInspector();
+                return;
+            }
+            EditorGUI.BeginChangeCheck();
+            LSBody[] Bodies = GenerateTargets();
+            LSBody Body = Bodies [0];
+			
+            if (Bodies.Length == 1)
+            {
+                Body._positionalTransform = (Transform)EditorGUILayout.ObjectField(
+                    "Positional Transform",
+                    Body._positionalTransform,
+                    typeof(Transform),
+                    true);
+                Body._rotationalTransform = (Transform)EditorGUILayout.ObjectField(
+                    "Rotational Transform",
+                    Body._rotationalTransform,
+                    typeof(Transform),
+                    true);
+
+                EditorGUILayout.Space();
+            }
+            Body.Layer = EditorGUILayout.LayerField("Layer", Body.Layer);
+			
+            for (int i = 0; i < Bodies.Length; i++)
+            {
+                LSBody body = Bodies [i];
+                Transform posTransform = body._positionalTransform != null ? body._positionalTransform : body.transform;
+                body._position = new Vector2d(posTransform.position);
+                Transform rotTransform = body._rotationalTransform != null ? body._rotationalTransform : body.transform;
+                body.Rotation = new Vector2d(Mathf.Sin(rotTransform.rotation.x), Mathf.Cos(rotTransform.rotation.y));
+            }
+
+            EditorGUILayout.LabelField("Collider Settings", EditorStyles.boldLabel);
+            Body.Shape = (ColliderType)EditorGUILayout.EnumPopup("Shape", Body.Shape);
+            for (int i = 1; i < Bodies.Length; i++)
+            {
+                Bodies [i].Shape = Body.Shape;
+            }
+            if (Body.Shape == ColliderType.None)
+            {
+                return;
+            }
+            Body.IsTrigger = EditorGUILayout.Toggle("Is Trigger", Body.IsTrigger);
+			
+            if (!Body.IsTrigger)
+            {
+                var ImmovableContent = new GUIContent("Immovable", "Is this object immovable, i.e. a wall. Note: non-immovable objects are not supported for any shape except circle.");
+                Body.Immovable = EditorGUILayout.Toggle(ImmovableContent, Body.Immovable);
+                if (!Body.Immovable)
+                {
+                    var PriorityContent = new GUIContent("Priority", "The priority of this object in collisions. Objects of lower priority yield to objects of higher priority.");
+                    SerializedProperty sp = serializedObject.FindProperty("_priority");
+                    sp.intValue = EditorGUILayout.IntField(PriorityContent, sp.intValue);
+                }
+            }
+            if (Body.Shape != ColliderType.None)
+            {
+
+            }
+            switch (Body.Shape)
+            {
+                case ColliderType.Circle:
+
+                    LSEditorUtility.FixedNumberField("Radius", ref Body.Radius);
+                    for (int i = 1; i < Bodies.Length; i++)
+                    {
+                        Bodies [i].Radius = Body.Radius;
+                    }
+                    break;
+                case ColliderType.AABox:
+                    LSEditorUtility.FixedNumberField("Half Width", ref Body.HalfWidth);
+                    LSEditorUtility.FixedNumberField("Half Height", ref Body.HalfHeight);
+                    for (int i = 1; i < Bodies.Length; i++)
+                    {
+                        Bodies [i].HalfWidth = Body.HalfWidth;
+                        Bodies [i].HalfHeight = Body.HalfHeight;
+                    }
+                    break;
+                case ColliderType.Polygon:
+                    if (Body.Vertices == null || Body.Vertices.Length == 0)
+                    {
+                        Body.Vertices = new Vector2d[4];
+                        Body.Vertices [0] = new Vector2d(FixedMath.Half, FixedMath.Half);
+                        Body.Vertices [1] = new Vector2d(FixedMath.Half, -FixedMath.Half);
+                        Body.Vertices [2] = new Vector2d(-FixedMath.Half, -FixedMath.Half);
+                        Body.Vertices [3] = new Vector2d(-FixedMath.Half, FixedMath.Half);
+                    }
+				
+                    int VerticesCount = EditorGUILayout.IntField("Vertices count", Body.Vertices.Length);
+				
+                    if (VerticesCount > Body.Vertices.Length)
+                    {
+                        var NewVertices = new Vector2d[VerticesCount];
+                        Body.Vertices.CopyTo(NewVertices, 0);
+                        for (int i = Body.Vertices.Length; i < VerticesCount; i++)
+                        {
+                            NewVertices [i] = new Vector2d(-FixedMath.One, 0);
+                        }
+                        Body.Vertices = NewVertices;
+                    } else if (VerticesCount < Body.Vertices.Length)
+                    {
+                        var NewVertices = new Vector2d[VerticesCount];
+                        for (int i = 0; i < VerticesCount; i++)
+                        {
+                            NewVertices [i] = Body.Vertices [i];
+                        }
+                        Body.Vertices = NewVertices;
+                    }
+                    for (int i = 0; i < Body.Vertices.Length; i++)
+                    {
+                        LSEditorUtility.Vector2dField("V" + i.ToString() + ":", ref Body.Vertices [i]);
+                    }
+                    for (int i = 1; i < Bodies.Length; i++)
+                    {
+                        Bodies [i].Vertices = Body.Vertices;
+                    }
+                    break;
+            }
+            for (int i = 1; i < Bodies.Length; i++)
+            {
+                Bodies [i].IsTrigger = Body.IsTrigger;
+                Bodies [i].Immovable = Body.Immovable;
+                Bodies [i].IsTrigger = Body.IsTrigger;
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RegisterCompleteObjectUndo(Body, "LSBody Change");
+                serializedObject.ApplyModifiedProperties();
+                SceneView.RepaintAll();
+            }
+        }
+
+        private static readonly Quaternion CapRotation = Quaternion.Euler(90, 0, 0);
+
+        public void OnSceneGUI()
+        {
+            if (Application.isPlaying)
+            {
+                return;
+            }
+            LSBody Body = (LSBody)(target);
+            Transform cachedTransform = Body.transform;
+            Vector3 TargetPosition = cachedTransform.position;
+            TargetPosition.y += .55f;
+            Vector3[] PolyLine;
+            switch (Body.Shape)
+            {
+                case ColliderType.Circle:
+                    Handles.color = FrameColor;
+                    Handles.CircleCap(1, TargetPosition, CapRotation, FixedMath.ToFloat(Body.Radius));
+                    Handles.CircleCap(1, TargetPosition, CapRotation, FixedMath.ToFloat(Body.Radius) + -.005f);
+                    Handles.CircleCap(1, TargetPosition, CapRotation, FixedMath.ToFloat(Body.Radius) + .005f);
+					
+                    Vector3 NewVec = TargetPosition;
+                    NewVec.x -= (float)Math.Round(FixedMath.ToDouble(Body.Radius), 4, MidpointRounding.AwayFromZero);
+                    Handles.color = MoveColor;
+                    NewVec = Handles.FreeMoveHandle(NewVec, Quaternion.identity, .35f, Vector3.zero, Handles.SphereCap);
+                    Body.Radius = FixedMath.Create(NewVec.x - TargetPosition.x);
+                    if (Body.Radius < 0)
+                    {
+                        Body.Radius = -Body.Radius;
+                    }
+                    break;
+                case ColliderType.AABox:
+                    float halfWidth = FixedMath.ToFloat(Body.HalfWidth);
+                    float halfHeight = FixedMath.ToFloat(Body.HalfHeight);
+                    PolyLine = new Vector3[5];
+                    for (int i = 0; i < 4; i++)
+                    {
+                        PolyLine [i] = TargetPosition;
+                    }
+					
+                    PolyLine [0].x += halfWidth;
+                    PolyLine [0].z += halfHeight;
+					
+                    PolyLine [1].x += halfWidth;
+                    PolyLine [1].z -= halfHeight;
+					
+                    PolyLine [2].x -= halfWidth;
+                    PolyLine [2].z -= halfHeight;
+					
+                    PolyLine [3].x -= halfWidth;
+                    PolyLine [3].z += halfHeight;
+					
+                    PolyLine [4] = PolyLine [0];
+                    Handles.color = FrameColor;
+                    Handles.DrawAAPolyLine(5f, PolyLine);
+                    Handles.color = MoveColor;
+					
+                    Vector3 WidthScaler = TargetPosition;
+                    WidthScaler.x -= (float)LSEditorUtility.Round(Body.HalfWidth);
+                    WidthScaler = Handles.FreeMoveHandle(WidthScaler, Quaternion.identity, .35f, Vector3.zero, Handles.SphereCap);
+                    Body.HalfWidth = FixedMath.Create(WidthScaler.x - TargetPosition.x);
+					
+                    Vector3 HeightScaler = TargetPosition;
+                    HeightScaler.z -= (float)LSEditorUtility.Round(Body.HalfHeight);
+                    HeightScaler = Handles.FreeMoveHandle(HeightScaler, Quaternion.identity, .35f, Vector3.zero, Handles.SphereCap);
+                    Body.HalfHeight = FixedMath.Create(HeightScaler.z - TargetPosition.z);
+                    if (Body.HalfWidth <= 0)
+                    {
+                        Body.HalfWidth = -Body.HalfWidth;
+                    }
+                    if (Body.HalfHeight < 0)
+                    {
+                        Body.HalfHeight = -Body.HalfHeight;
+                    }
+					
+                    break;
+                case ColliderType.Polygon:
+                    if (Body.Vertices == null || Body.Vertices.Length == 0)
+                    {
+                        break;
+                    }
+					
+                    PolyLine = new Vector3[Body.Vertices.Length + 1];
+                    Handles.color = MoveColor;
+                    for (int i = 0; i < Body.Vertices.Length; i++)
+                    {
+                        //TODO: Handle world scaling
+                        Vector3 vertPos = Body.Vertices [i].ToVector3(0f) + TargetPosition;
+                        Vector3 freemoveVec = Handles.FreeMoveHandle(vertPos, Quaternion.identity, .35f, Vector3.zero, Handles.SphereCap) - TargetPosition;
+                        Body.Vertices [i] = new Vector2d(FixedMath.Create(freemoveVec.x), FixedMath.Create(freemoveVec.z));
+                        Handles.Label(vertPos, "V" + i.ToString());
+                        PolyLine [i] = vertPos;
+                    }
+					
+                    PolyLine [Body.Vertices.Length] = PolyLine [0];
+                    Handles.color = FrameColor;
+                    Handles.DrawAAPolyLine(5f, PolyLine);
+                    break;
+            }
+
+        }
+
+        private LSBody[] GenerateTargets()
+        {
+            return Array.ConvertAll<UnityEngine.Object,LSBody>(targets, (x) =>
+            {
+                return (LSBody)x;
+            });
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Integration/Editor/LSBodyEditor.cs.meta b/Integration/Editor/LSBodyEditor.cs.meta
new file mode 100644
index 00000000..454d4195
--- /dev/null
+++ b/Integration/Editor/LSBodyEditor.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 281db6f49ccf3b34b84a4909f4680061
+timeCreated: 1434434515
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Integration/Editor/LSEditorUtility.cs b/Integration/Editor/LSEditorUtility.cs
index 81c921c4..fa585db3 100644
--- a/Integration/Editor/LSEditorUtility.cs
+++ b/Integration/Editor/LSEditorUtility.cs
@@ -4,7 +4,7 @@
 using Lockstep;
 using System;
 using UnityEditor;
-using Lockstep.Rotorz.ReorderableList;
+using Rotorz.ReorderableList;
 using TypeReferences;
 using System.Reflection.Emit;
 using System.Reflection;
@@ -103,9 +103,9 @@ public static void BoolGrid (string content, ref BoolArray2D values)
         {
             if (showBoolGrid = EditorGUILayout.Foldout (showBoolGrid, content))
             {
-                int newWidth = EditorGUILayout.IntField ("Width", values.Width);
-                int newHeight = EditorGUILayout.IntField ("Height", values.Height);
-                values.Resize (newWidth, newHeight);
+                values.Width = EditorGUILayout.IntField ("Width", values.Width);
+                values.Height = EditorGUILayout.IntField ("Height", values.Height);
+
                 const float cellWidth = 20;
                 const float cellHeight = 20f;
                 Rect drawSource = EditorGUILayout.GetControlRect ();
diff --git a/Core/Game/Player/Commands/Default.meta b/Integration/Editor/untitled folder.meta
similarity index 67%
rename from Core/Game/Player/Commands/Default.meta
rename to Integration/Editor/untitled folder.meta
index 1752ba92..00914e3f 100644
--- a/Core/Game/Player/Commands/Default.meta
+++ b/Integration/Editor/untitled folder.meta	
@@ -1,7 +1,7 @@
 fileFormatVersion: 2
-guid: 933328b84a89d46c2b6f8669b0dd7987
+guid: 94b52cbb7ed96455c91435c9f1ac44f5
 folderAsset: yes
-timeCreated: 1451622238
+timeCreated: 1449254212
 licenseType: Pro
 DefaultImporter:
   userData: 
diff --git a/Integration/Environment/DefaultSaver.cs b/Integration/Environment/DefaultSaver.cs
index 7b47bb58..d507ca90 100644
--- a/Integration/Environment/DefaultSaver.cs
+++ b/Integration/Environment/DefaultSaver.cs
@@ -6,7 +6,7 @@ namespace Lockstep
 {
     public class DefaultSaver : EnvironmentSaver
     {
-        [SerializeField]
+        [SerializeField, HideInInspector]
         private EnvironmentBodyInfo[] _environmentBodies;
         public EnvironmentBodyInfo[] EnvironmentBodies {get {return _environmentBodies;}}
         [SerializeField, HideInInspector]
@@ -42,7 +42,7 @@ void SaveBodies () {
                 if (IsAgent(body)) continue;
                 EnvironmentBodyInfo bodyInfo = new EnvironmentBodyInfo(
                     body,
-                    new Vector2dHeight(body.transform.position),
+                    new Vector2d(body.transform.position),
                     new Vector2d (Mathf.Sin (body.transform.rotation.x), Mathf.Cos (body.transform.rotation.y))
                 );
                 bodiesBuffer.Add(bodyInfo);
diff --git a/Integration/Environment/EnvironmentBodyInfo.cs b/Integration/Environment/EnvironmentBodyInfo.cs
index 2284583e..3ebc64e9 100644
--- a/Integration/Environment/EnvironmentBodyInfo.cs
+++ b/Integration/Environment/EnvironmentBodyInfo.cs
@@ -8,7 +8,7 @@ public class EnvironmentBodyInfo
     {
         public EnvironmentBodyInfo (
             LSBody body,
-            Vector2dHeight position,
+            Vector2d position,
             Vector2d rotation
         )
         {
@@ -18,7 +18,7 @@ Vector2d rotation
         }
 
         public LSBody Body;
-        public Vector2dHeight Position;
+        public Vector2d Position;
         public Vector2d Rotation;
     }
 }
\ No newline at end of file
diff --git a/Integration/Environment/EnvironmentHelper.cs b/Integration/Environment/EnvironmentHelper.cs
index 4cdb1958..b17775e9 100644
--- a/Integration/Environment/EnvironmentHelper.cs
+++ b/Integration/Environment/EnvironmentHelper.cs
@@ -6,11 +6,11 @@ namespace Lockstep
     public class EnvironmentHelper : BehaviourHelper
     {
 
-        public override ushort ListenInput
+        public override InputCode ListenInput
         {
             get
             {
-                return 0;
+                return InputCode.None;
             }
         }
 
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuBuilder.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuBuilder.cs
old mode 100644
new mode 100755
index 88cc372d..925206e0
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuBuilder.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuBuilder.cs	
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Factory methods that create <see cref="IElementAdderMenuBuilder{TContext}"/>
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuCommandAttribute.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuCommandAttribute.cs
old mode 100644
new mode 100755
index 8156295a..3135721c
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuCommandAttribute.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMenuCommandAttribute.cs	
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Annotate <see cref="IElementAdderMenuCommand{TContext}"/> implementations with a
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMeta.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMeta.cs
old mode 100644
new mode 100755
index 6e7b74fa..44d4f8a7
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMeta.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/ElementAdderMeta.cs	
@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Provides meta information which is useful when creating new implementations of
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenu.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenu.cs
old mode 100644
new mode 100755
index 156dc5d1..a855d4ea
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenu.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenu.cs	
@@ -4,7 +4,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	internal sealed class GenericElementAdderMenu : IElementAdderMenu {
 
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenuBuilder.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenuBuilder.cs
old mode 100644
new mode 100755
index edaae56e..a3bbf56e
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenuBuilder.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/GenericElementAdderMenuBuilder.cs	
@@ -6,7 +6,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	internal sealed class GenericElementAdderMenuBuilder<TContext> : IElementAdderMenuBuilder<TContext> {
 
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdder.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdder.cs
old mode 100644
new mode 100755
index 3030199c..3535e8eb
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdder.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdder.cs	
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Interface for an object which adds elements to a context object of the type
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenu.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenu.cs
old mode 100644
new mode 100755
index 7c878280..540370cf
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenu.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenu.cs	
@@ -3,7 +3,7 @@
 
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Interface for a menu interface.
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuBuilder.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuBuilder.cs
old mode 100644
new mode 100755
index e46021a9..783891fb
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuBuilder.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuBuilder.cs	
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Interface for building an <see cref="IElementAdderMenu"/>.
diff --git a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuCommand.cs b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuCommand.cs
old mode 100644
new mode 100755
index 8bd6a24f..be6eb7ca
--- a/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuCommand.cs	
+++ b/Integration/Rotorz/ReorderableList/Editor/Element Adder Menu/IElementAdderMenuCommand.cs	
@@ -3,7 +3,7 @@
 
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Interface for a menu command that can be included in an <see cref="IElementAdderMenu"/>
diff --git a/Integration/Rotorz/ReorderableList/Editor/GenericListAdaptor.cs b/Integration/Rotorz/ReorderableList/Editor/GenericListAdaptor.cs
old mode 100644
new mode 100755
index 42a529a0..c7b29c6a
--- a/Integration/Rotorz/ReorderableList/Editor/GenericListAdaptor.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/GenericListAdaptor.cs
@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Reorderable list adaptor for generic list.
diff --git a/Integration/Rotorz/ReorderableList/Editor/IReorderableListAdaptor.cs b/Integration/Rotorz/ReorderableList/Editor/IReorderableListAdaptor.cs
old mode 100644
new mode 100755
index a462e899..1aa3112d
--- a/Integration/Rotorz/ReorderableList/Editor/IReorderableListAdaptor.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/IReorderableListAdaptor.cs
@@ -3,7 +3,7 @@
 
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Adaptor allowing reorderable list control to interface with list data.
diff --git a/Integration/Rotorz/ReorderableList/Editor/IReorderableListDropTarget.cs b/Integration/Rotorz/ReorderableList/Editor/IReorderableListDropTarget.cs
old mode 100644
new mode 100755
index 3663dae1..f94d4525
--- a/Integration/Rotorz/ReorderableList/Editor/IReorderableListDropTarget.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/IReorderableListDropTarget.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Rotorz Limited. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root.
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Can be implemented along with <see cref="IReorderableListAdaptor"/> when drop
diff --git a/Integration/Rotorz/ReorderableList/Editor/Internal/GUIHelper.cs b/Integration/Rotorz/ReorderableList/Editor/Internal/GUIHelper.cs
old mode 100644
new mode 100755
index b4b007e6..7bd8df25
--- a/Integration/Rotorz/ReorderableList/Editor/Internal/GUIHelper.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/Internal/GUIHelper.cs
@@ -6,7 +6,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList.Internal {
 
 	/// <summary>
 	/// Utility functions to assist with GUIs.
diff --git a/Integration/Rotorz/ReorderableList/Editor/Internal/ReorderableListResources.cs b/Integration/Rotorz/ReorderableList/Editor/Internal/ReorderableListResources.cs
old mode 100644
new mode 100755
index 640f427f..44b6c962
--- a/Integration/Rotorz/ReorderableList/Editor/Internal/ReorderableListResources.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/Internal/ReorderableListResources.cs
@@ -5,7 +5,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList.Internal {
 
 	/// <exclude/>
 	public enum ReorderableListTexture {
diff --git a/Integration/Rotorz/ReorderableList/Editor/Internal/SerializedPropertyUtility.cs b/Integration/Rotorz/ReorderableList/Editor/Internal/SerializedPropertyUtility.cs
index 4cdb2a41..f1a22f92 100755
--- a/Integration/Rotorz/ReorderableList/Editor/Internal/SerializedPropertyUtility.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/Internal/SerializedPropertyUtility.cs
@@ -5,7 +5,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList.Internal {
+namespace Rotorz.ReorderableList.Internal {
 
 	/// <summary>
 	/// Utility functionality for <see cref="SerializedPropertyAdaptor"/> implementations.
diff --git a/Integration/Rotorz/ReorderableList/Editor/ReorderableListControl.cs b/Integration/Rotorz/ReorderableList/Editor/ReorderableListControl.cs
index dbb40640..dd596cc0 100755
--- a/Integration/Rotorz/ReorderableList/Editor/ReorderableListControl.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/ReorderableListControl.cs
@@ -1,12 +1,12 @@
 // Copyright (c) Rotorz Limited. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root.
 #if UNITY_EDITOR
-using Lockstep.Rotorz.ReorderableList.Internal;
+using Rotorz.ReorderableList.Internal;
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 	
 	/// <summary>
 	/// Base class for custom reorderable list control.
diff --git a/Integration/Rotorz/ReorderableList/Editor/ReorderableListEvents.cs b/Integration/Rotorz/ReorderableList/Editor/ReorderableListEvents.cs
old mode 100644
new mode 100755
index 1784a576..de5fc63f
--- a/Integration/Rotorz/ReorderableList/Editor/ReorderableListEvents.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/ReorderableListEvents.cs
@@ -5,7 +5,7 @@
 using System.ComponentModel;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 	
 	/// <summary>
 	/// Arguments which are passed to <see cref="AddMenuClickedEventHandler"/>.
diff --git a/Integration/Rotorz/ReorderableList/Editor/ReorderableListGUI.cs b/Integration/Rotorz/ReorderableList/Editor/ReorderableListGUI.cs
index c32b5df0..4720a6e4 100755
--- a/Integration/Rotorz/ReorderableList/Editor/ReorderableListGUI.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/ReorderableListGUI.cs
@@ -5,7 +5,7 @@
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Utility class for drawing reorderable lists.
diff --git a/Integration/Rotorz/ReorderableList/Editor/ReorderableListStyles.cs b/Integration/Rotorz/ReorderableList/Editor/ReorderableListStyles.cs
old mode 100644
new mode 100755
index fe425f5f..bbd4e09c
--- a/Integration/Rotorz/ReorderableList/Editor/ReorderableListStyles.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/ReorderableListStyles.cs
@@ -1,11 +1,11 @@
 // Copyright (c) Rotorz Limited. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root.
 
-using Lockstep.Rotorz.ReorderableList.Internal;
+using Rotorz.ReorderableList.Internal;
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 	
 	/// <summary>
 	/// Styles for the <see cref="ReorderableListControl"/>.
diff --git a/Integration/Rotorz/ReorderableList/Editor/SerializedPropertyAdaptor.cs b/Integration/Rotorz/ReorderableList/Editor/SerializedPropertyAdaptor.cs
index dac57232..c61e51f3 100755
--- a/Integration/Rotorz/ReorderableList/Editor/SerializedPropertyAdaptor.cs
+++ b/Integration/Rotorz/ReorderableList/Editor/SerializedPropertyAdaptor.cs
@@ -1,12 +1,12 @@
 // Copyright (c) Rotorz Limited. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root.
 #if UNITY_EDITOR
-using Lockstep.Rotorz.ReorderableList.Internal;
+using Rotorz.ReorderableList.Internal;
 using System;
 using UnityEditor;
 using UnityEngine;
 
-namespace Lockstep.Rotorz.ReorderableList {
+namespace Rotorz.ReorderableList {
 
 	/// <summary>
 	/// Reorderable list adaptor for serialized array property.
diff --git a/Integration/Rotorz/ReorderableList/ReorderableListFlags.cs b/Integration/Rotorz/ReorderableList/ReorderableListFlags.cs
index 32f74638..4b93d3e9 100755
--- a/Integration/Rotorz/ReorderableList/ReorderableListFlags.cs
+++ b/Integration/Rotorz/ReorderableList/ReorderableListFlags.cs
@@ -3,7 +3,7 @@
 #if UNITY_EDITOR
 using System;
 
-namespace Lockstep.Rotorz.ReorderableList
+namespace Rotorz.ReorderableList
 {
 
     /// <summary>
diff --git a/README.md b/README.md
index 3dbae205..054e9b0b 100644
--- a/README.md
+++ b/README.md
@@ -1,43 +1,37 @@
+TODO: Update README with information about the recent changes.
+
 Lockstep Framework
 ------------------------
-The Lockstep Framework (LSF) is a framework designed for games that especially need lockstep simulations. It includes a deterministic 2D physics engine, pathfinding, behavior system, and more. LSF is integrated with Unity.
-
-Special thanks to Liv Games (http://www.livgames.com) and 360 Studio (http://www.360studio.me) for supporting the development of Lockstep Framework.
-
-Under development by [John Pan](https://github.com/SnpM) and Lam Pham (https://github.com/LamPham).
+The Lockstep Framework (LSF) is a framework designed for games that especially need lockstep simulations. It includes a deterministic 2D physics engine, pathfinding, behavior system, and more. LSF is integrated with Unity but can be abstracted away.
 
-Features
-__________
-- Deterministic math library and simulation logic
-- 2D physics engine on the X-Z plane.
-- Behaviour system for both individual agents and globally
-- Lockstep variables - know when and where desyncs happen
-- Size-based pathfinding (big units won't get stuck in those narrow gaps)
-- Customizable database system
-- Support for Forge Networking (DarkRift and Photon coming soon)
+Under development by [John Pan](https://github.com/SnpM).
 
 Quick Setup
 -----------
-1. Import the framework into a Unity project and open Lockstep-Framework/Example/ExampleScene
-2. Set up the database and settings by navigating to the Lockstep/Database window or pressing Control - Shift - L.
-3. In the Settings foldout of the database window, click Load and navigate to Lockstep-Framework/Example/ExampleDatabase/Example_Database.asset to load the preconfigured database for the example.
-4. Play!
+Download the entire Lockstep Framework project and import it into your Unity assets.
 
-Note: The example only shows the basic functionality of the framework. Comprehensive examples will be added close to the end of core development.
+Locate the Manager prefab in Core/Example/ and add that into your scene. This prefab comes with 3 components attached: LockstepManager, TestManager, and PlayerManager. LockstepManager contains settings for simulation and non-simulation related things that many other pieces of the LSF use.
 
-TODO:
--------
-These are high priority issues that are significantly big or complicated. Any help on these aspects (as well as on any other lacking parts of the framework) would be very appreciated.
-- Interpolation. Through a combination of interpolation and extrapolation on unexpectedly late simulation frames, interpolation works correctly without another layer so the unit will always only be 1 frame behind the actual position. For some reason, there's still some smooth stuttering when VSync is turned off in the editor. The brunt of the interpolation code stems from PhysicsManager.Visualize().
-- (After Lockstep Variables are fully tested) Lockstep Variable integration. Currently, no abilities use Lockstep Variables which are used to track determinism and also reset values upon re-initialization of the unit. A lot of work must be done to mark as many value-type deterministic variables as possible [Lockstep] and move their initialization to Setup () since LSVariables automatically handle resetting.
-- Integrations for various networking solutions (i.e. DarkRift, Photon, UNet, Bolt)
-- Safe and scalable coding patterns. Anywhere you see something that might cause problems for a large-scale project, fixing it or raising an issue would be a big help. LSF started as a work of curiosity and passion. While it's introduced me to helpful experiences, I didn't always see the flaw in using statics everywhere. If there are any significantly limiting problems with a component's design, I'll do my best to fix it.
-- Implement and test polygon colliders.
+TestManager is an example of the script you would write to interact with the LSF. It creates an AgentController, creates 256 agents under that AgentController, and adds the AgentController to PlayerManager for the player to interact with that controller. In FixedUpdate and Update, LockstepManager.Simulate () and LockstepManager.Visualize () are called, respectively. These distribute necessary information to the LSF for when to execute frames.
 
-Road Map
----------
-- Semi-3D physics (may be coming soon!). Physics calculations on the Y axis requires non-trivial changes but collision detection for objects like bullets may be able to be hacked in.
-- Multi engine support. Customizable support for game engines in addition to Unity could make this framework viable for many more people.
+Click play and enjoy the lockstep simulation of group behaviors and collision responses.
+
+Ability Pattern
+----------------
+Abilities are moddable behaviors that can be easily attached, detached, and moddified on prefab game objects. They follow the following pattern:
+- The overridable Initialize() method is called when the agent the ability belongs to is created and initialized. It provides an argument that is the agent the ability belongs to. Because LSF uses object pooling, the Ability must also be reset in Initialize().
+- Simulate() is called every single simulation frame.
+- Deactivate() is called when the ability's agent is deactivated (i.e. killed). Note that Simulate() will not be called until after Initialize() is called again.
+
+ActiveAbility Pattern
+_____________________________
+ActiveAbility inherits from Ability and includes all the patterns described above. In addition ActiveAbilitys can be interacted with by players through Commands.
+- Execute () is called when a Command is received and activates the ability. This method provides an argument that is the Command responsible for the ability's activation.
+- The ListenInput property is the input that the ability listens to. If a Command with the InputCode of ListenInput is received, Execute () is called on the ability.
+ 
+Essential Abilities
+-------------------
+Currently, only movement with crowd behaviors is implemented. If you'd like to contribute, please explore Core/Game/Abities/Essential/ and help create more essential behaviors (i.e. Health, Energy, Attack, Stop).
 
 License
 --------
@@ -63,19 +57,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-//Ability info will go in docs later
-/*
-Ability Pattern
-----------------
-Abilities are moddable behaviors that can be easily attached, detached, and moddified on prefab game objects. They follow the following pattern:
-- The overridable Initialize() method is called when the agent the ability belongs to is created and initialized. It provides an argument that is the agent the ability belongs to. Because LSF uses object pooling, the Ability must also be reset in Initialize(). Note: Lockstep varaibles are implemented but not tested. These will make resetting in Initialize obsolete.
-- Simulate() is called every single simulation frame (FixedUpdate frames).
-- Visualize is called every render frame (Update frames).
-- Deactivate() is called when the ability's agent is deactivated (i.e. killed). Note that Simulate() will not be called until after Initialize() is called again.
-
-ActiveAbility Pattern
-_____________________________
-ActiveAbility inherits from Ability and includes all the patterns described above. In addition ActiveAbilitys can be interacted with by players through Commands.
-- Execute () is called when a Command is received and activates the ability. This method provides an argument that is the Command responsible for the ability's activation.
- */
-
+Note
+_____
+Due to time concerns, I'm not actively developing this repository at the moment.
diff --git a/Resources.meta b/Resources.meta
deleted file mode 100644
index 821e09c9..00000000
--- a/Resources.meta
+++ /dev/null
@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: ecd5b8d320a3b4c18aff077125218d61
-folderAsset: yes
-timeCreated: 1451867013
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Resources/DefaultLockstepFrameworkSettings.asset b/Resources/DefaultLockstepFrameworkSettings.asset
deleted file mode 100644
index 07937f17..00000000
Binary files a/Resources/DefaultLockstepFrameworkSettings.asset and /dev/null differ
diff --git a/Settings/LSFSettingsManager.cs b/Settings/LSFSettingsManager.cs
index 6fd9454d..76bbbf9c 100644
--- a/Settings/LSFSettingsManager.cs
+++ b/Settings/LSFSettingsManager.cs
@@ -4,47 +4,33 @@
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
-namespace Lockstep
-{
-    public static class LSFSettingsManager
-    {
-        public const string DEFAULT_SETTINGS_NAME = "DefaultLockstepFrameworkSettings";
-        public const string SETTINGS_NAME = "LockstepFrameworkSettings";
+namespace Lockstep {
+    public static class LSFSettingsManager {
+        public const string SETTINGS_NAME = "LockstepFrameworkSettings.asset";
         static LSFSettings MainSettings;
 
-        static LSFSettingsManager()
-        {
-            LSFSettings settings = Resources.Load<LSFSettings>(SETTINGS_NAME);
+        static LSFSettingsManager () {
+            LSFSettings settings = Resources.Load<LSFSettings> (SETTINGS_NAME);
 #if UNITY_EDITOR
-            if (settings == null)
-            {
-                if (Application.isPlaying == false)
+            if (Application.isPlaying == false) {
+                if (settings == null)
                 {
-
-                    settings = ScriptableObject.CreateInstance <LSFSettings>();
+                    settings = ScriptableObject.CreateInstance <LSFSettings> ();
                     if (!System.IO.Directory.Exists(Application.dataPath + "/Resources"))
-                        AssetDatabase.CreateFolder("Assets", "Resources");
-                    AssetDatabase.CreateAsset(settings, "Assets/Resources/" + SETTINGS_NAME + ".asset");
+                        AssetDatabase.CreateFolder ("Assets","Resources");
+                    AssetDatabase.CreateAsset (settings,"Assets/Resources/" + SETTINGS_NAME + ".asset");
                     AssetDatabase.SaveAssets();
-                    AssetDatabase.Refresh();
-                
-                } else
-                {
-                    settings = Resources.Load<LSFSettings>(DEFAULT_SETTINGS_NAME);
+                    AssetDatabase.Refresh ();
                 }
             }
 #endif
-
             MainSettings = settings;
-            if (MainSettings == null)
-            {
-                throw new System.NullReferenceException("No LockstepFrameworkSettings detected. Make sure there is one in the root directory of a Resources folder");
+            if (MainSettings == null) {
+                throw new System.NullReferenceException ("No LockstepFrameworkSettings detected. Make sure there is one in the root directory of a Resources folder");
             }
-
         }
 
-        public static LSFSettings GetSettings()
-        {
+        public static LSFSettings GetSettings () {
             return MainSettings;
         }