public void AddObject(Point index, MapObject obj)
        {
            if (!_objects.ContainsKey(index))
                _objects.Add(index, new List<MapObject>());

            _objects[index].Add(obj);
        }

 public void CreateGeometry(MapObject parent)
 {
     foreach (Aerofoil aerofoil in aerofoils)
     {
         aerofoil.CreateGeometry(parent, this);
     }
 }

        protected override void OnGetObjectBounds( MapObject obj, List<Rect> rectangles )
        {
            //RTSCharacter
            RTSCharacter character = obj as RTSCharacter;
            if( character != null )
            {
                float radius = character.Type.Radius;
                rectangles.Add( new Rect(
                    obj.Position.ToVec2() - new Vec2( radius, radius ),
                    obj.Position.ToVec2() + new Vec2( radius, radius ) ) );
                return;
            }

            //all other objects
            if( obj.PhysicsModel != null )
            {
                foreach( Body body in obj.PhysicsModel.Bodies )
                {
                    foreach( Shape shape in body.Shapes )
                    {
                        if( shape.ContactGroup == (int)ContactGroup.NoContact )
                            continue;

                        Bounds bounds = shape.GetGlobalBounds();
                        rectangles.Add( new Rect( bounds.Minimum.ToVec2(), bounds.Maximum.ToVec2() ) );
                    }
                }
                return;
            }

            //base.OnGetObjectBounds( obj, rectangles );
        }

    protected override void Start()
    {
        base.Start();

        mapObject = GetComponent<MapObject>();
        movement = GetComponent<SimpleMovement>();
    }

        internal static Rectangle UpdateCollision(this GameObject gameObject, Rectangle Destination, Rectangle old, MapObject currentMap)
        {
            foreach (GameTile tile in currentMap.Tiles)
            {
                if (tile.ValidTile && Destination.Intersects(tile.Destination))
                {

                    Rectangle newDestinationXOnly = new Rectangle(Destination.X, old.Y, gameObject.Width, gameObject.Height);
                    Rectangle newDestinationYOnly = new Rectangle(old.X, Destination.Y, gameObject.Width, gameObject.Height);
                    if (newDestinationXOnly.Intersects(tile.Destination))
                    {
                        Destination.X = old.X;
                    }

                    if (newDestinationYOnly.Intersects(tile.Destination))
                    {

                        Destination.Y = old.Y;

                        if (gameObject.Center.Y < tile.Destination.Y)
                        {
                            gameObject.IsJumping = false;
                            gameObject.CurrentSpeed = 0;
                        }
                    }
                }
            }

            return Destination;
        }

        public void addMapObject(MapObject mapObject)
        {
            if (this.mapObjects == null)
                this.mapObjects = new List<MapObject>();

            this.mapObjects.Add(mapObject);
        }

 public void AddObjectClone(MapObject obj)
 {
     MapObject o = (MapObject)obj.Clone();
     o.MapX %= 2 * (Config.BigTileEdgeSize + 1);
     o.MapY %= 2 * (Config.BigTileEdgeSize + 1);
     Objects.Add(o);
 }

        public ObjectWrapper(MapObject mapObject, Point index)
        {
            _object = mapObject;
            _index = index;

            DrawPrioirty = _index.X * 1000 + _index.Y;
            IsDrawable = true;
        }

        public void TestMoveUp()
        {
            var movableObject = new MapObject {Position = new MapPosition(5, 7)};

            movableObject.Position = new MapPosition(movableObject.Position, new PositionChange {Y = 1});

            Assert.AreEqual(new MapPosition(5, 8), movableObject.Position);
        }

        public void TestMoveRight()
        {
            var movableObject = new MapObject {Position = new MapPosition(6, 2)};

            movableObject.Position = new MapPosition(movableObject.Position, new PositionChange{X = 1});

            Assert.AreEqual(new MapPosition(7, 2), movableObject.Position);
        }

        public void TestMoveLeft()
        {
            var movableObject = new MapObject {Position = new MapPosition(4, 4)};

            movableObject.Position = new MapPosition(movableObject.Position, new PositionChange {X = -1});

            Assert.AreEqual(new MapPosition(3, 4), movableObject.Position);
        }

        public void TestMoveDown()
        {
            var movableObject = new MapObject {Position = new MapPosition(8, 1)};

            movableObject.Position = new MapPosition(movableObject.Position, new PositionChange{Y = -1});

            Assert.AreEqual(new MapPosition(8, 0), movableObject.Position);
        }

        public void TestAddOneMovableObject()
        {
            var map = new Map();
            var movableObject = new MapObject();
            map.AddObject(movableObject);

            Assert.AreEqual(1, map.GetNumDrawables());
            Assert.AreEqual(movableObject, map.GetDrawable(0));
        }

 public Map(int mapSize)
 {
     this.mapSize = mapSize;
     this.map = new MapObject [mapSize][];
     for (int i = 0; i < map.Length; ++i)
     {
         map[i] = new MapObject[mapSize];
     }
 }

 void MapChangeRegion_ObjectIn( Entity entity, MapObject obj )
 {
     if( PlayerIntellect.Instance != null && PlayerIntellect.Instance.ControlledObject == obj )
     {
         PlayerCharacter.ChangeMapInformation playerCharacterInformation =
             ( (PlayerCharacter)PlayerIntellect.Instance.ControlledObject ).GetChangeMapInformation( this );
         GameWorld.Instance.SetShouldChangeMap( mapName, spawnPointName,
             playerCharacterInformation );
     }
 }

        public override int Pushed(MapObject pusher, MirDirection dir, int distance)
        {
            int result = base.Pushed(pusher, dir, distance);

            if (result > 0)
            {
                if (pusher is PlayerObject) Attacked((PlayerObject)pusher, Math.Max(50, Envir.Random.Next((int)MaxHP)), DefenceType.Repulsion);
                else if (pusher is MonsterObject) Attacked((MonsterObject)pusher, Math.Max(50, Envir.Random.Next((int)MaxHP)), DefenceType.Repulsion);
            }
            return result;
        }

		public static bool HitsMapObject(this Ray ray, MapObject obj, float maxDistance = 2048)
		{
			ray.Direction = ray.Direction.GetNormalize() * maxDistance;
			RayCastResult[] piercingResult = PhysicsWorld.Instance.RayCastPiercing(ray, (int)ContactGroup.CastAll);
			foreach (var res in piercingResult)
			{
				if (res.Distance < maxDistance && res.Shape.Body._InternalUserData != null && res.Shape.Body._InternalUserData == obj)
					return true;
			}
			return false;
		}

        public void TestBlockingObjectCanShareCoordinateWithNonBlocking()
        {
            var map = new Map();
            var blockingObject = new MapObject {Position = new MapPosition(4, 4)};
            var nonBlockingObject = new MapObject {Position = new MapPosition(4, 3), Blocking = false};
            map.AddObject(blockingObject);
            map.AddObject(nonBlockingObject);

            map.Move(blockingObject, new PositionChange {Y = -1});

            Assert.AreEqual(new MapPosition(4, 3), blockingObject.Position);
        }

        public void TestAddTwoMovableObjects()
        {
            var map = new Map();
            var movableObject1 = new MapObject();
            map.AddObject(movableObject1);
            var movableObject2 = new MapObject();
            map.AddObject(movableObject2);

            Assert.AreEqual(2, map.GetNumDrawables());
            Assert.AreEqual(movableObject1, map.GetDrawable(0));
            Assert.AreEqual(movableObject2, map.GetDrawable(1));
        }

 public void registerNewLocation(Vector2 coords, int number, string objType)
 {
     switch (objType) {
     case "City":
         if (cities[number] == null)
             cities[number] = new MapObject(coords, number, objType);
         break;
     case "Lab":
         if (labs[number] == null)
             labs[number] = new MapObject(coords, number, objType);
         break;
     }
 }