public bool TryGetSpace(IEntity entity, ISpace dreamPosition)
 {
     var res = FullSpaces.Any(s => s.Area.Intersects(dreamPosition.Area));
     if (!res)
         entitiesSpaces.Add(Tuple.Create(entity, dreamPosition));
     return !res;
 }

	void Awake() {
		int[,] boardArr;

		var spaceArr = new ISpace<Tiles>[dims, dims];
		board = new TileSudokuBoard((int) dims, spaceArr);

		switch (SceneManager.GetActiveScene().name) {
		case "Tutorial":
			boardArr = tutorialBoard;
			board.EndPos = new int[] {2, 2};
			break;
		case "MainGame":
		default:
			Debug.Log ("name is " + SceneManager.GetActiveScene().name);
			boardArr = normalBoard;
			break;
		}


		if (prefab==null)
			throw new System.Exception("missing spacewrapper prefab");
		//var spaceArr = new ISpace<Tiles>[dims, dims];
		for (var i = 0; i < dims; ++i)
			for (var j = 0; j < dims; ++j) {
				spaceArr [i, j] = CreateSpaceWrapper (i, j, (Tiles)boardArr [i, j]);
				Debug.Log ("Set Tile " + boardArr [i, j].ToString () + " at position" + i.ToString () + ", " + j.ToString());

			}
	}

        public override void Expand(ISpace space, Point markedPoint, Point unmarkedPoint)
        {
            Point prev = markedPoint;
            Point cur = unmarkedPoint;

            ScreenConstructionParameters scp = new ScreenConstructionParameters(cur, TerminalName, m_fractalCreator);

            space.AddScreen(scp, this.MissionNodeID);
            space.ConnectTwoWay(prev, cur, (Connection)space.GetConnection(prev, cur));

            if (m_objectPopulators.Count >= 1) scp.ObjectPopulator = m_objectPopulators[0];
            if (m_postProcessors.Count >= 1) scp.PostProcessor = m_postProcessors[0];

            for (int i = 1; i < m_length; ++i)
            {
                prev = cur;
                cur = DirectionUtils.Move(cur, m_bestEvaledDirection);

                scp = new ScreenConstructionParameters(cur, TerminalName, m_fractalCreator);

                space.AddScreen(scp, this.MissionNodeID);
                space.ConnectTwoWay(prev, cur, Connection.Open);

                if (m_objectPopulators.Count > i) scp.ObjectPopulator = m_objectPopulators[i];
                if (m_postProcessors.Count > i) scp.PostProcessor = m_postProcessors[i];
            }

            prev = cur;

            space.ConnectOneWay(prev, m_bestEvaledDirection.Move(prev), Connection.Door);
            space.ConnectOneWay(prev, m_bestEvaledDirection.RotationCW.Move(prev), Connection.Door);
            space.ConnectOneWay(prev, m_bestEvaledDirection.RotationCCW.Move(prev), Connection.Door);
        }

 public void FreeSpace(IEntity entity, ISpace space)
 {
     int index = entitiesSpaces.FindIndex(t => t.Item1 == entity && t.Item2 == space);
     if(index == -1 )
         throw new InvalidOperationException("Record is not in collection.");
     entitiesSpaces.RemoveAt(index);
 }

 public void OnAdditionToSpace(ISpace newSpace)
 {
     foreach(OperationalMachine o in machines)
         newSpace.Add(o);
     foreach(BaseModel m in models)
         newSpace.Add(m);
 }

 void Awake()
 {
     if (prefab==null)
         throw new System.Exception("missing spacewrapper prefab");
     var spaceArr = new ISpace<Tiles>[dims, dims];
     for (var i=0; i<dims; ++i)
         for (var j=0; j<dims; ++j)
             spaceArr[i,j] = CreateSpaceWrapper(i,j);
     board = new TileSudokuBoard((int) dims, spaceArr);
 }

        private IEnumerable<ISpaceRouteElement> GetToSpace(IEntity entity, Tile currentTile, ISpace destSpace)
        {
            bool found = false;
            ISpace currentSpace = entity.Location.Space; //currentTile.LayoutManager.FindCurrentSpace(entity);

            if (currentSpace == destSpace)
                return new FourthSpaceRouteElement(currentSpace, currentTile).ToEnumerable();

            searcher.LayoutManager = currentTile.LayoutManager;
            searcher.StartSearch(AllSpaces.First(), currentSpace, 1, (space, layer, bundle) =>
            {
                if (space == destSpace)
                {
                    searcher.StopSearch();
                    found = true;
                }
            });

            return found ? searcher.GetShortestRoute(destSpace).Select(s => new FourthSpaceRouteElement(s, currentTile)) : null;
        }

        public override float Evaluate(ISpace space, Point markedPoint, Point unmarkedPoint)
        {
            // walk m_length tiles and verify they are all free
            Point cur = unmarkedPoint;
            for (int i = 0; i < m_length; ++i)
            {
                if (!space.IsAreaFree(cur)) return float.PositiveInfinity;
                cur = DirectionUtils.Move(cur, m_direction);
            }

            // went one too far, so back up to last tile in the dealio
            cur = DirectionUtils.Move(cur, m_direction.Opposite);

            int blockedCount = 0;
            if (!space.IsAreaFree(cur)) blockedCount++;
            if (!space.IsAreaFree(DirectionUtils.Move(cur, m_exitDir.RotationCW))) blockedCount++;
            if (!space.IsAreaFree(DirectionUtils.Move(cur, m_exitDir.RotationCCW))) blockedCount++;
            if (!space.IsAreaFree(DirectionUtils.Move(cur, m_exitDir))) blockedCount++;

            return blockedCount / 4.0f;
        }

        public override float Evaluate(ISpace space, Point markedPoint, Point unmarkedPoint)
        {
            float bestCost = float.PositiveInfinity; // worst possible, best possible is 0

            foreach (Direction dir in m_directions)
            {
                // walk m_length tiles and verify they are all free
                Point cur = unmarkedPoint;
                int counter = 0;
                int blockedCounter = 0;
                for (int i = 0; i < m_length; ++i)
                {
                    if (!space.IsAreaFree(cur))
                    {
                        blockedCounter = Int32.MaxValue - 5;
                        break;
                    }

                    counter += 2;
                    if (!space.IsAreaFree(dir.RotationCW.Move(cur))) blockedCounter++;
                    if (!space.IsAreaFree(dir.RotationCCW.Move(cur))) blockedCounter++;

                    cur = dir.Move(cur);
                }

                counter++;
                if (!space.IsAreaFree(cur)) blockedCounter++; // one past the end

                float score = (float)blockedCounter / counter;

                if (score < bestCost)
                {
                    bestCost = score;
                    m_bestEvaledDirection = dir;
                }
            }

            return bestCost;
        }

        public override void Expand(ISpace space, Point markedPoint, Point unmarkedPoint)
        {
            Point prev = markedPoint;
            Point cur = unmarkedPoint;

            ScreenConstructionParameters scp = new ScreenConstructionParameters(cur, TerminalName, m_fractalCreator);

            space.AddScreen(scp, this.MissionNodeID);
            space.ConnectTwoWay(prev, cur, Connection.Door);

            for (int i = 1; i < m_length; ++i)
            {
                prev = cur;
                cur = DirectionUtils.Move(cur, m_direction);

                scp = new ScreenConstructionParameters(cur, TerminalName, m_fractalCreator);

                space.AddScreen(scp, this.MissionNodeID);
                space.ConnectTwoWay(prev, cur, Connection.Open);

                if (i != m_length - 1)
                {
                    Point side = DirectionUtils.Move(cur, m_direction.RotationCW);
                    space.ConnectOneWay(cur, side, Connection.Door);
                    side = DirectionUtils.Move(cur, m_direction.RotationCCW);
                    space.ConnectOneWay(cur, side, Connection.Door);
                }
            }

            prev = cur;
            //cur = m_direction.Move(cur, m_exitDir);
            space.ConnectOneWay(prev, m_direction.Move(prev), Connection.Door);
            space.ConnectOneWay(prev, m_direction.RotationCW.Move(prev), Connection.Door);
            space.ConnectOneWay(prev, m_direction.RotationCCW.Move(prev), Connection.Door);
            //space.ConnectOneWay(prev, cur, Connection.Door);
        }

        internal void OnRemovalFromSpace(ISpace space)
        {
            space.Remove(shape.detector);

            shape.OnRemovalFromSpace(space);
        }

 public void OnRemovalFromSpace(ISpace oldSpace)
 {
     oldSpace.Remove(Model);
     oldSpace.Remove(joint);
     Model.Ent.CollisionInformation.Events.PairTouching -= onCollision;
 }

 public void OnAdditionToSpace(ISpace newSpace)
 {
     newSpace.Add(Model);
     newSpace.Add(joint);
     Model.Ent.CollisionInformation.Events.PairTouching += onCollision;
 }

 public Plan(ITile tile, ISpace space)
 {
     Tile = tile;
     Space = space;
     Arguments = new List<object>();
     Worths = new Dictionary<IPlayer, int>();
 }

        private int GetSpaceWorth(ISpace space, IPlayer player)
        {
            int worth;
            lock (_lock)
                if (_spaceWorths.TryGetValue(new Tuple<ISpace, IPlayer>(space, player), out worth))
                    return worth;

            var visited = new HashSet<ITile>();
            if (space.Tile != null)
                visited.Add(space.Tile);

            var groups = new List<List<ITile>>();
            foreach (ITile tile in space.AdjacentTiles.Where(t => t.HasToken(player) && !visited.Contains(t)))
            {
                var group = new List<ITile>();
                var queue = new Queue<ITile>(new[] {tile});
                while (queue.Count>0)
                {
                    ITile query = queue.Dequeue();
                    visited.Add(query);
                    group.Add(query);
                    foreach (ITile adj in query.Space.AdjacentTiles.Where(t => t.HasToken(player) && !visited.Contains(t)))
                        queue.Enqueue(adj);
                }
                groups.Add(group);
            }

            int[] sizes = groups.Select(g => g.Count).ToArray();
            if (sizes.Length == 0 || sizes.Sum()<GameState.SmallestScoringGroup-1)
                worth = 0;
            else
                worth = 1+sizes.Where(i => i<GameState.SmallestScoringGroup).Sum();

            lock (_lock)
                _spaceWorths[new Tuple<ISpace, IPlayer>(space, player)] = worth;
            return worth;
        }

 public FourthSpaceRouteElement(ISpace space, Tile parentTile)
 {
     Space = space;
     Tile = parentTile;
 }

 public override void OnRemovalFromSpace(ISpace oldSpace)
 {
     //Remove any supplements from the space too.
     oldSpace.Remove(Body);
     oldSpace.Remove(HorizontalMotionConstraint);
     oldSpace.Remove(VerticalMotionConstraint);
     //This character controller requires the standard implementation of Space.
     ((Space)oldSpace).BoundingBoxUpdater.Finishing -= ExpandBoundingBox;
     SupportFinder.ClearSupportData();
     Body.AngularVelocity = new Vector3();
     Body.LinearVelocity = new Vector3();
 }

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

        internal void OnAdditionToSpace(ISpace space)
        {
            detector.CollisionInformation.collisionRules.Specific.Add(wheel.vehicle.Body.CollisionInformation.collisionRules, CollisionRule.NoBroadPhase);
            detector.CollisionInformation.collisionRules.Personal = CollisionRule.NoNarrowPhaseUpdate;
            detector.CollisionInformation.collisionRules.group = CollisionRules.DefaultDynamicCollisionGroup;

        }

        void ISpaceObject.OnAdditionToSpace(ISpace newSpace)
        {

        }