C# IGrid类代码示例

    public GridEventManager(ISetting setting, IGrid grid, IGroupFactory groupFactory)
    {
        _grid = grid;
        _groupFactory = groupFactory;

        _setting = setting;
    }

        public void Run(ref IGrid grid, SelectionFunction SelectionFunction)
        {
            var startAt = grid.GetRandomCell;
            active = new Stack<Cell>();
            active.Push(startAt);

            while(active.Any())
            {
                var cell = SelectionFunction(active);  
                var availableNeighbors = cell.Neighbors.Where(x => x.Links.Count == 0);

                if (availableNeighbors.Any())
                {
                    var neighbor = availableNeighbors.Sample();
                    cell.Link(neighbor);
                    active.Push(neighbor);
                }
                else
                {
                    var list = active.ToList();
                    list.Remove(cell);
                    active = new Stack<Cell>(list);
                }
            }
        }

 public IEnumerable<Point> GetEmptySquares(IGrid grid)
 {
     for (int x = 0; x < grid.Size; x++)
         for (int y = 0; y < grid.Size; y++)
             if (grid[x, y].Content == TileContent.Empty)
                 yield return new Point(x, y);
 }

 public GridPagingSettings(IGrid grid)
 {
     this.grid = grid;
     Style = GridPagerStyles.NextPreviousAndNumeric;
     CurrentPage = 1;
     PageSizesInDropDown = new[] {5, 10, 20, 50};            
 }

        public GridGroupingSettings(IGrid grid)
        {
            this.grid = grid;

            Groups = new List<GroupDescriptor>();
            Visible = true;
        }

        public Scene(float bandLambda, float breakingThreshold, float timeStep, int stepSize, IGrid grid)
        {
            TimeStep = timeStep;
            StepSize = stepSize;
            Stopwatch = new Stopwatch();

            var center = new Vector2(grid.Width, grid.Height) / 2;
            var offset = -center;

            Nodes = grid.Vertices.Select(v => new Node(v + offset)).ToArray();

            var edges = grid.Edges;
            Bands = new Band[edges.Count];

            for (int i = 0; i < edges.Count; i++)
            {
                var edge = edges[i];
                float length = Vector2.Distance(Nodes[edge.Index1].Position, Nodes[edge.Index2].Position);
                float restLength = 0.95f * length;
                Bands[i] = new Band(edge.Index1, edge.Index2, bandLambda, restLength, restLength * breakingThreshold);
            }

            BandCount = edges.Count;
            Impulses = new Vector2[Nodes.Length];
            PreviousImpulses = new Vector2[Nodes.Length];
        }

        /// <summary>
        /// Prints the labyrinth to the console
        /// </summary>
        /// <param name="grid">the playfield</param>
        public void PrintLabirynth(IGrid grid)
        {
            Console.ForegroundColor = ConsoleColor.DarkCyan;
            Console.WriteLine(" " + new string('\u2593', (grid.TotalRows * 2) + 3));

            for (int row = 0; row < grid.TotalRows; row++)
            {
                Console.Write("{0,2}", "\u2593");
                for (int col = 0; col < grid.TotalCols; col++)
                {
                    var currentCell = grid.GetCell(row, col);
                    if (currentCell == GlobalConstants.PlayerSignSymbol)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.DarkCyan;
                    }

                    Console.Write("{0,2}", currentCell);
                }

                Console.Write("{0,2}", "\u2593");
                Console.WriteLine();
            }
            Console.WriteLine(" " + new string('\u2593', (grid.TotalCols * 2) + 3));
        }

        public void plant_mines_on(IGrid grid)
        {
            var coordinates = _random_coordinate_picker.pick_coordinates_from(_game_difficulty.minefield_size, _game_difficulty.number_of_mines);

            foreach(var coordinate in coordinates)
                grid.plant_mine_at(coordinate);
        }

    public Game(IGrid grid, ISetting setting)
    {
        _setting = setting;
        _grid = grid;

        currentControl = _grid;
    }

 public Piece GetWinner(IGrid grid)
 {
     foreach (var p in new[] { Piece.X, Piece.O })
         if (GetWinnableLines(grid.Size).Any(line => line.All(pos => p == grid[pos].Content)))
             return p;
     return null;
 }

        private static void MoveRover(IGrid grid, string locationLine, string movesLine)
        {
            IDirectionParser directionParser = (IDirectionParser)container[typeof(IDirectionParser)];
            ILocationParser locationParser = (ILocationParser)container[typeof(ILocationParser)];

            Direction direction = directionParser.GetDirection(locationLine);
            Point location = locationParser.GetLocation(locationLine);
            IMoveSupplier supplier = (IMoveSupplier)container[typeof(IMoveSupplier)];

            supplier.Init(movesLine);
            Rover rover = new Rover(direction, location, grid, supplier);
            try
            {
                rover.ExecuteMoves();
            }
            catch (InvalidLocationException ex)
            {
                Console.WriteLine(MarsRover.IllegalLocation);
            }
            Console.WriteLine(String.Format("{0} {1} {2}", rover.Location.X, rover.Location.Y, rover.Direction));

            container.Release(supplier);
            container.Release(directionParser);
            container.Release(locationParser);
        }

        public IGrid<Cell> On(IGrid<Cell> grid, Cell startAt = null)
        {
            if (startAt == null)
            {
                startAt = grid.RandomCell();
            }

            var stack = new Stack<Cell>();
            stack.Push(startAt);

            while (stack.Count != 0)
            {
                var current = stack.Peek();
                var neighbours = current.Neighbours().Where(n => n.Links.Count == 0).ToList();
                if (neighbours.Count == 0)
                {
                    stack.Pop();
                }
                else
                {
                    var neighbour = neighbours[rand.Next(neighbours.Count)];
                    current.Link(neighbour);
                    stack.Push(neighbour);
                }


            }

            return grid;
        }

    public SmartCPUBehaviour(IGrid grid, ISetting setting, CPUMode difficulty)
    {
        _grid = grid;
        _gridSimulator = new GridSimulator(grid, setting);
        _outputter = new OutputBestMovement(_gridSimulator);
        _grid.OnGroupAdd += new OnGroupAddEventHandler(OnGroupAddEvent);

        Debug.Log("difficulty " + difficulty + "set");
        switch(difficulty)
        {
            case CPUMode.Easy:
                timeBeforeAction = 0.5f;
                timeBetweenActions = 0.5f;
                break;
            case CPUMode.Normal:
                timeBeforeAction = 0.5f;
                timeBetweenActions = 0.3f;
                break;
            case CPUMode.Hard:
                timeBeforeAction = 0.2f;
                timeBetweenActions = 0.1f;
                break;
            case CPUMode.Kusotuyo:
                timeBeforeAction = 0f;
                timeBetweenActions = 0f;
                break;
        }
    }

        /// <summary>
        /// Generete game field
        /// </summary>
        /// <param name="grid">Field member</param>
        /// <param name="player"Player member></param>
        /// <returns>Genereted game filed</returns>
        public IGrid GenerateGrid(IPlayer player, IGrid grid)
        {
            DefaultRandomGenerator random = DefaultRandomGenerator.Instance();
            int percentageOfBlockedCells = random.Next(GlobalConstants.MinimumPercentageOfBlockedCells, GlobalConstants.MaximumPercentageOfBlockedCells);

            for (int row = 0; row < grid.TotalRows; row++)
            {
                for (int col = 0; col < grid.TotalCols; col++)
                {
                    int num = random.Next(0, 100);
                    if (num < percentageOfBlockedCells)
                    {
                        grid.SetCell(row, col, GlobalConstants.BlockedCellSymbol);
                    }
                    else
                    {
                        grid.SetCell(row, col, GlobalConstants.FreeCellSymbol);
                    }
                }
            }

            grid.SetCell(grid.TotalRows / 2, grid.TotalCols / 2, GlobalConstants.PlayerSignSymbol);

            this.MakeAtLeastOneExitReachable(grid, player);
            return grid;
        }

        public void Run(ref IGrid grid)
        {
            var current = grid.GetRandomCell;

            while(current != null)
            {
                var unvisitedNeighbors = current.Neighbors.Where(x => x.Links.Count == 0); // get all neighbors of cell that does not have any links (yet)

                if (unvisitedNeighbors.Count() > 0)
                {
                    var neighbor = unvisitedNeighbors.Sample<Cell>();
                    current.Link(neighbor);
                    current = neighbor;
                }
                else
                {
                    current = null;
                }

                foreach(var cell in grid)
                {
                    var visitedNeighbors = cell.Neighbors.Where(x => x.Links.Count() > 0);
                    if ((cell.Links.Count == 0 || cell.Links== null) && visitedNeighbors.Count() > 0)
                    {
                        current = cell;

                        var neighbor = visitedNeighbors.Sample<Cell>();
                        current.Link(neighbor);

                        break;
                    }
                }
            }
        }