static void Main(string[] args)
        {
            using (var space = new Space())
            {

            }
        }

 /// <summary>
 /// Called before an object is removed from its space.
 /// </summary>
 public override void OnRemovalFromSpace(Space oldSpace)
 {
     for (int i = 0; i < solverUpdateables.Count; i++)
     {
         solverUpdateables[i].OnRemovalFromSpace(oldSpace);
     }
 }

 public override void OnReset()
 {
     if (translation != null) {
         translation.Value = Vector3.zero;
     }
     relativeTo = Space.Self;
 }

 public override void Reset()
 {
     gameObject = null;
     moveVector = new FsmVector3 {UseVariable = true};
     space = Space.World;
     perSecond = true;
 }

    // Use this for initialization
    void Awake()
    {
        Debug.Assert(SaveGameEventSubscription == null && AutoSaveGameEventSubscription == null);
        SaveGameEventSubscription= MessageHub.Subscribe<SaveGameEvent>(SaveGame);
        AutoSaveGameEventSubscription = MessageHub.Subscribe<AutoSaveGameEvent>(AutoSaveGame);

        mapData = new CollectedMapData();

        space = GameObject.Find("Space").GetComponent<Space>();
        if (space == null)
        {
            throw new MissingComponentException("Unable to find Space. The big bang doesn't have enough space to happen. The 'Space' game object also needs to be added to the level and have the space script attached.");
        }

        airTrafficControl = GameObject.Find("AirTrafficControl").GetComponent<AirTrafficControl>();
        if (space == null)
        {
            throw new MissingComponentException("Unable to find AirTrafficControl. There can't be any troops flying around without an global AirTrafficControl GameObject that has an AirTrafficControl Script attached.");
        }

        gameState = GameObject.Find("2D_MainCam").GetComponent<GameState>();
        if (gameState == null)
        {
            throw new MissingComponentException("Unable to find GameState. The 'GameState' script needs to be attached to the same Gameobject as the BigBang.");
        }
        playerManager = GameObject.Find("PlayerManagement").GetComponent<PlayerManager>();
        if (playerManager == null)
        {
            throw new MissingComponentException("Unable to find playerManager.");
        }
    }

 public static void SetZ(this Transform transform, float z, Space space = Space.Self)
 {
     if (space == Space.Self)
         transform.localPosition = transform.localPosition.ScaleBy(1, 1, 0) + z*Vector3.forward;
     else
         transform.position = transform.position.ScaleBy(1, 1, 0) + z*Vector3.forward;
 }

        public void Done()
        {
            if (SpaceName != null)
                SpaceName = SpaceName.Trim();
            if (string.IsNullOrWhiteSpace(SpaceName))
            {
                MessageBox.Show("Profile name is empty", "Locality", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
            if (SpaceName.Length > 30)
            {
                MessageBox.Show("Profile name is too long", "Locality", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            foreach (var spc in App.Instance.Config.Spaces)
                if (spc.Name.Equals(SpaceName, StringComparison.InvariantCultureIgnoreCase))
                {
                    MessageBox.Show("This profile already exists", "Locality", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

            var s = new Space { Name = SpaceName, Id = Guid.NewGuid().ToString() };
            App.Instance.Config.Spaces.Add(s);
            (Parent as RootViewModel).Back();
        }

 public static void SetY(this Transform transform, float y, Space space = Space.Self)
 {
     if (space == Space.Self)
         transform.localPosition = transform.localPosition.ScaleBy(1, 0, 1) + y*Vector3.up;
     else
         transform.position = transform.position.ScaleBy(1, 0, 1) + y*Vector3.up;
 }

 public override void Reset()
 {
     this.gameObject = null;
     this.space = Space.World;
     this.storePosition = null;
     this.everyFrame = false;
 }

        public void AttachGO(Transform dest, Transform source, Vector3 position, Quaternion rotation, Vector3 scale,
            Space space = Space.Self)
        {
            if (source == null)
                return;

            if (dest == null)
            {
                source.parent = null;
            }
            else
            {
                source.parent = dest.transform;
            }
            if (space == Space.Self)
            {
                source.transform.localPosition = position;
                source.transform.localRotation = rotation;
            }
            else
            {
                source.transform.position = position;
                source.transform.rotation = rotation;
            }
            source.transform.localScale = scale;
        }

		public override void Reset()
		{
			gameObject = null;
			space = Space.World;
			storePosition = null;
			everyFrame = false;
		}

 public override void OnReset()
 {
     if (eulerAngles != null) {
         eulerAngles.Value = Vector3.zero;
     }
     relativeTo = Space.Self;
 }

    void Update()
    {
        if (!Application.isEditor)
        {
            Destroy(this);
            return;
        }

        if (FreezePosition)
        {
            // Save current position if enabled
            if ((FreezePosition != m_OldFreezePosition) || (space != m_OldSpace))
                m_Position = (space == Space.World) ? transform.position : transform.localPosition;
            // Freeze the position
            if (space == Space.World)
                transform.position = m_Position;
            else
                transform.localPosition = m_Position;
        }

        if (FreezeRotation)
        {
            // Save current rotation if enabled
            if ((FreezeRotation != m_OldFreezeRotation) || (space != m_OldSpace))
                m_Rotation = (space == Space.World) ? transform.rotation : transform.localRotation;
            // Freeze the rotation
            if (space == Space.World)
                transform.rotation = m_Rotation;
            else
                transform.localRotation = m_Rotation;
        }
        m_OldSpace = space;
        m_OldFreezePosition = FreezePosition;
        m_OldFreezeRotation = FreezeRotation;
    }

    /// <summary>
    /// Function for applying a specific type of force to a Rigidbody2D (since the default functionality is incomplete)
    /// </summary>
    /// <param name="rb2d">Rigidbody2D to apply the force to</param>
    /// <param name="force">The amount of force to apply</param>
    /// <param name="mode">What type of force to apply</param>
    /// <param name="relativeTo">Should the force be applied in the rigidbody's local space, or world space?</param>
    public static void AddForce2D(this Rigidbody2D rb2d, Vector2 force, ForceMode mode = ForceMode.Force, Space relativeTo = Space.World)
    {
        ForceMode2D mode2D = ForceMode2D.Force;
        Vector2 forceApplied = force;
        switch (mode)
        {
            case ForceMode.Impulse:
                mode2D = ForceMode2D.Impulse;
                break;
            case ForceMode.Acceleration:
                forceApplied *= rb2d.mass;
                break;
            case ForceMode.VelocityChange:
                forceApplied = force * rb2d.mass / Time.fixedDeltaTime;
                break;
            case ForceMode.Force:
                //nothing special
                break;
        }

        if (relativeTo == Space.Self)
            rb2d.AddRelativeForce(forceApplied, mode2D);
        else if (relativeTo == Space.World)
            rb2d.AddForce(forceApplied, mode2D);
    }

 public override void Reset()
 {
     gameObject = null;
     speed = null;
     speedVector = null;
     space = Space.World;
 }

 public override void Reset()
 {
     gameObjects = new FsmGameObject[1];
     storePositions = new FsmVector3[1];
     space = Space.World;
     everyFrame = false;
 }

    void Awake()
    {
        InputHandler.OnZoom += this.Zoom;               // Subscribe to Zoom Event
        InputHandler.OnTouchMove += this.OnTouchMove;   // Subscribe to OnTouchMove Event

        var spaceGO = GameObject.Find("Space");
        if (spaceGO == null) {
            throw new MissingComponentException("Unable to find Space GameObject. This should be a global GO that contains the Space script.");
        }
        _map = spaceGO.GetComponent<Space>();
        if (_map == null) {
            throw new MissingComponentException("Unable to find space script. This component should be attached to the Space GameObject.");
        }

        _cameraWidthHalf = Camera.main.orthographicSize * Camera.main.aspect;
        _cameraHeightHalf = Camera.main.orthographicSize;

        _smallestPlanetDiameter = 25; // _map.GetSmallestDiameter();

        RecalculateCameraMinAndMaxSize();

        float cameraInitOrthoSize = Mathf.Max(_cameraMaxOrthoSize, _cameraMinOrthoSize) * 2 / 3; // max function is needed when the map returns a size of 0
        Camera.main.orthographicSize = cameraInitOrthoSize;
        _moveToPosition = _map.transform.position;

        _cameraOrthoSizeTo = Camera.main.orthographicSize; // needed? yes otherwise the first scroll is using zero as startpoint
        //_moveToPosition = FindHomePlanet();
    }

 public static void SetX(this Transform transform, float x, Space space = Space.Self)
 {
     if (space == Space.Self)
         transform.localPosition = transform.localPosition.ScaleBy(0, 1, 1) + x*Vector3.right;
     else
         transform.position = transform.position.ScaleBy(0, 1, 1) + x*Vector3.right;
 }

 public override void Reset()
 {
     base.Reset();
     this.id = new FsmString
     {
         UseVariable = true
     };
     this.time = 1f;
     this.delay = 0f;
     this.loopType = iTween.LoopType.none;
     this.vector = new FsmVector3
     {
         UseVariable = true
     };
     this.speed = new FsmFloat
     {
         UseVariable = true
     };
     this.space = Space.World;
     this.orientToPath = false;
     this.lookAtObject = new FsmGameObject
     {
         UseVariable = true
     };
     this.lookAtVector = new FsmVector3
     {
         UseVariable = true
     };
     this.lookTime = 0f;
     this.axis = iTweenFsmAction.AxisRestriction.none;
 }

 /// <summary>
 /// Called after the object is added to a space.
 /// </summary>
 /// <param name="newSpace"></param>
 public override void OnAdditionToSpace(Space newSpace)
 {
     for (int i = 0; i < solverUpdateables.Count; i++)
     {
         solverUpdateables[i].OnAdditionToSpace(newSpace);
     }
 }