/// <summary>
        /// ��һ��Map��ӵ�������
        /// </summary>
        /// <param name="Map"></param>
        public void Add(IMap Map)
        {
            if (Map == null)
                throw new Exception("Maps::Add:\r\n�µ�ͼû�г�ʼ��!");

            _mapList.Add(Map);
        }

        private void BuildCorridor(IMap map, MapCell currentCell)
        {
            MapCell nextCell;
            var direction = Dir.Zero;

            bool success;
            do
            {
                _directionPicker.LastDirection = direction;
                _directionPicker.ResetDirections();
                var emptySide = currentCell.Sides
                    .Single(s => s.Value != Side.Wall)
                    .Key;
                success = false;
                do
                {
                    direction = _directionPicker.NextDirectionExcept(emptySide);
                    success = map.TryGetAdjacentCell(currentCell, direction, out nextCell);

                    if (success)
                    {
                        map.CreateCorridorSide(currentCell, nextCell, direction, Side.Empty);
                    }
                } while (_directionPicker.HasDirections && !success);

                if (!success)
                {
                    return;
                }
            } while (currentCell.IsDeadEnd);
        }

 public PlanetGenerator(IMap map, IRandom random)
 {
     _map = map;
     _random = random;
     MaximumMapSize = new Size(10000,10000);
     MaximumPlanetSize = 250;
 }

        private IMap pMap = null; // ����pMap

        #endregion Fields

        #region Constructors

        public frmAttribute(IMap ppMap,int iLayerID)
        {
            InitializeComponent();
            pMap = ppMap;
            pLayerID = iLayerID;
            pfrmAttribute = this;
        }

 public static IFeatureLayer FindMyFeatureLayer(IMap inMap, string inName)
 {
     string isfound = "false";
     ILayer tempLayer;
     IFeatureLayer goodLayer = new FeatureLayerClass();
     for (int i = 0; i < inMap.LayerCount; i++)
     {
         tempLayer = inMap.get_Layer(i);
         if (tempLayer is IFeatureLayer)
         {
             if (tempLayer.Name == inName)
             {
                 isfound = "true";
                 goodLayer = tempLayer as IFeatureLayer;
             }
         }
     }
     //duplicate name in the map.? How we deal with it
     if (isfound == "true")
     {
         return goodLayer;
     }
     else
     {
         return null;
     }
 }

 public AdventureStage(IMap map , IStorage storage , User user)
 {
     _User = user;
     _Observeds = new List<IObservedAbility>();
     _Stroage = storage;
     _Map = map;
 }

 internal PathToPlayer( Player player, IMap map, Texture2D sprite )
 {
     _player = player;
      _map = map;
      _sprite = sprite;
      _pathFinder = new PathFinder( map );
 }

        /// <summary>
        /// Constructs a new PathFinder instance for the specified Map
        /// </summary>
        /// <param name="map">The Map that this PathFinder instance will run shortest path algorithms on</param>
        /// <exception cref="ArgumentNullException">Thrown on null map</exception>
        public PathFinder( IMap map )
        {
            if ( map == null )
             {
            throw new ArgumentNullException( "map", "Map cannot be null" );
             }

             _map = map;
             _graph = new EdgeWeightedDigraph( _map.Width * _map.Height );
             foreach ( Cell cell in _map.GetAllCells() )
             {
            if ( cell.IsWalkable )
            {
               int v = IndexFor( cell );
               foreach ( Cell neighbor in _map.GetBorderCellsInRadius( cell.X, cell.Y, 1 ) )
               {
                  if ( neighbor.IsWalkable )
                  {
                     int w = IndexFor( neighbor );
                     _graph.AddEdge( new DirectedEdge( v, w, 1.0 ) );
                     _graph.AddEdge( new DirectedEdge( w, v, 1.0 ) );
                  }
               }
            }
             }
        }

        private static int CalculateRoomScore(Room room, IMap map, MapCell cell)
        {
            var currentScore = 0;

            foreach (var roomCell in room)
            {
                var currentCell = map[
                    roomCell.Location.X + cell.Location.X,
                    roomCell.Location.Y + cell.Location.Y];

                currentScore += AdjacentCorridorBonus
                    * roomCell.Sides
                        .Count(s => HasAdjacentCorridor(map, currentCell, s.Key));

                if (currentCell.IsCorridor)
                {
                    currentScore += OverlappedCorridorBonus;
                }

                currentScore += OverlappedRoomBonus
                    * map.Rooms.Count(r => r.Bounds.Contains(currentCell.Location));
            }

            return currentScore;
        }

        public static EffectItem Create( IPoint3D p, IMap map, TimeSpan duration )
        {
            EffectItem item = null;

            for ( int i = m_Free.Count - 1; item == null && i >= 0; --i ) // We reuse new entries first so decay works better
            {
                EffectItem free = (EffectItem) m_Free[i];

                m_Free.RemoveAt( i );

                if ( !free.Deleted && free.Map == Map.Internal )
                    item = free;
            }

            if ( item == null )
            {
                item = new EffectItem();
            }
            else
            {
                item.ItemID = 1;
            }

            item.MoveToWorld( new Point3D( p ), map as Map );
            item.BeginFree( duration );

            return item;
        }

        public bool HandleInput(InputState inputState, IMap map) {
            var potential_new_x = X;
            var potential_new_y = Y;
            bool trying_to_move = false;

            if (inputState.IsLeft(PlayerIndex.One)) {
                potential_new_x = X - speed;
                trying_to_move = true;
            } else if (inputState.IsRight(PlayerIndex.One)) {
                potential_new_x = X + speed;
                trying_to_move = true;
            } else if (inputState.IsUp(PlayerIndex.One)) {
                potential_new_y = Y - speed;
                trying_to_move = true;
            } else if (inputState.IsDown(PlayerIndex.One)) {
                potential_new_y = Y + speed;
                trying_to_move = true;
            }


            if (trying_to_move) {
                if (map.IsWalkable(potential_new_x, potential_new_y)) {
                    var enemy = Global.CombatManager.EnemyAt(potential_new_x, potential_new_y);
                    if (enemy == null) {
                        X = potential_new_x;
                        Y = potential_new_y;
                    } else {
                        Global.CombatManager.Attack(this, enemy);
                    }

                    return true;
                }
            }
            return false;
        }

 public StepOnButton(string triggerName, bool global, IMap map, Rectangle rect, int id)
     : base(map, rect, id)
 {
     _triggerName = triggerName;
     _global = global;
     _objectType = 84;
 }

 public override string ChangeTableName(IMap @from, IMap to) {
     var sql = new StringBuilder("alter table ");
     this.AppendQuotedTableName(sql, from);
     sql.Append(" rename to ");
     this.AppendQuotedTableName(sql, to);
     return sql.ToString();
 }

        protected override void ExecuteCommand(IMap map, DungeonParameters parameters)
        {
            var sparseFactor = parameters.CellSparseFactor;
            var expectedNumberOfRemovedCells =
                   (int)Math.Ceiling(map.Size * (sparseFactor / 100m)) - 1;

            var removedCellsCount = 0;
            var nonWalls = map.Where(c => !c.IsWall).ToList();
            if (!nonWalls.Any())
            {
                throw new InvalidOperationException("All cells are walls.");
            }

            while (removedCellsCount < expectedNumberOfRemovedCells)
            {
                foreach (var cell in nonWalls.Where(c => c.IsDeadEnd).ToList())
                {
                    if (!cell.IsDeadEnd)
                        continue;

                    var emptySide = cell.Sides
                        .Single(s => s.Value != Side.Wall)
                        .Key;

                    map.CreateWall(cell, emptySide);
                    cell.IsCorridor = false;
                    nonWalls.Remove(cell);
                    removedCellsCount++;
                }
            }
        }

 public override bool Update(IMap map, float seconds)
 {
     bool alive = base.Update(map, seconds);
     Modules.ModuleManager.DoEffect(4, map, -this.Movement, this.Rect.Center, "");
     map.SetGlow(_id, this.MidPosition, Microsoft.Xna.Framework.Color.Green, 20, false, 300);
     return alive;
 }

 public static IMosaicLayer FindMyMosaicLayer(IMap inMap, string inName)
 {
     string isfound = "false";
     ILayer tempLayer;
     IMosaicLayer goodMLayer = new MosaicLayerClass();
     for (int i = 0; i < inMap.LayerCount; i++)
     {
         tempLayer = inMap.get_Layer(i);
         if (tempLayer is IMosaicLayer)
         {
             if (tempLayer.Name == inName)
             {
                 isfound = "true";
                 goodMLayer = tempLayer as IMosaicLayer;
             }
         }
     }
     if (isfound == "true")
     {
         return goodMLayer;
     }
     else
     {
         return null;
     }
 }

        public int CompareTo(IMap other)
        {
            int										compare;
            IEnumerator<KeyValuePair<Value, Value>>	lhs;
            IEnumerator<KeyValuePair<Value, Value>>	rhs;

            if (other == null)
                return 1;

            if (this.Count < other.Count)
                return -1;
            else if (this.Count > other.Count)
                return 1;

            lhs = this.GetEnumerator ();
            rhs = other.GetEnumerator ();

            while (lhs.MoveNext () && rhs.MoveNext ())
            {
                compare = lhs.Current.Key.CompareTo (rhs.Current.Key);

                if (compare != 0)
                    return compare;

                compare = lhs.Current.Value.CompareTo (rhs.Current.Value);

                if (compare != 0)
                    return compare;
            }

            return 0;
        }

        private void FindOneToOnes(IMap map, IAnswerProvider answerProvider) {
            foreach (var column in map.Columns.Where(c => c.Value.Relationship == RelationshipType.ManyToOne)) {
                var otherMapCandidates =
                    column.Value.ParentMap.Columns.Where(
                        c => c.Value.Type == column.Value.Map.Type && (column.Value.ParentMap != map || c.Key != column.Key)).ToArray();
                if (otherMapCandidates.Length == 0) {
                    continue;
                }
                else if (otherMapCandidates.Length == 1) {
                    column.Value.Relationship = RelationshipType.OneToOne; // one relationship coming back, assume one to one
                    column.Value.OppositeColumn = otherMapCandidates.First().Value;
                }
                else {
                    // we've got more than 1 foreign key coming back - let's ask the user
                    var choices = otherMapCandidates.Select(c => new MultipleChoice<IColumn> { DisplayString = c.Key, Choice = c.Value }).ToList();
                    const string oneToOneText = "No matching column but one-to-one";
                    const string manyToOneText = "No matching column but many-to-one";
                    choices.Add(new MultipleChoice<IColumn> { DisplayString = oneToOneText, Choice = new Column<string> { Name = "One to One" } });
                    choices.Add(new MultipleChoice<IColumn> { DisplayString = manyToOneText, Choice = new Column<string> { Name = "Many to One" } });
                    var oppositeColumn =
                        answerProvider.GetMultipleChoiceAnswer(
                            "The column " + column.Key + " on " + column.Value.Map.Table
                            + " has multiple incoming relationships. Which column on the related table is the other side of the one-to-one relationship?",
                            choices);
                    if (oppositeColumn.DisplayString == manyToOneText) {
                        continue; // many to one
                    }

                    column.Value.Relationship = RelationshipType.OneToOne;
                    if (oppositeColumn.DisplayString != oneToOneText) {
                        column.Value.OppositeColumn = oppositeColumn.Choice;
                    }
                }
            }
        }

 public frmWeightedAverageByAreaOrLength(IMap map)
 {
     InitializeComponent();
     rsUtil = new rasterUtil();
     mp = map;
     populateComboBox();
 }

 public frmSummarizeByField(IMap map)
 {
     InitializeComponent();
     rsUtil = new rasterUtil();
     mp = map;
     populateComboBox();
 }