C# MapObject类代码示例

        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 );
     }
 }