public override List<Cell> GetCellNeighbours(int i, int j, Board board)
        {
            List<Cell> neighbours = base.GetCellNeighbours(i,j,board); //Add radius 1 neighbours

            int startIndex, endIndex;
            int size = board.Size;

            //Add radius 2 neighbours

            //Add top & bottom cells
            startIndex = j > 1 ? j - 2 : 0;
            endIndex = j < size - 2 ? j + 2 : size - 1;

            if (i > 1)
            {

                for (int x = startIndex; x <= endIndex; x++)
                {
                    neighbours.Add(board[i - 2,x]);
                }

            }

            if (i < size - 2)
            {
                for (int x = startIndex; x <= endIndex; x++)
                {
                    neighbours.Add(board[i + 2, x]);
                }
            }

            //Add side neighbours
            startIndex = i > 0 ? i - 1 : 0;
            endIndex = i < size - 1 ? i + 1 : size - 1;

            if (j > 1)
            {

                for (int x = startIndex; x <= endIndex; x++)
                {
                    neighbours.Add(board[x, j-2]);
                }

            }

            if (j < size - 2)
            {
                for (int x = startIndex; x <= endIndex; x++)
                {
                    neighbours.Add(board[x , j + 2]);
                }
            }

            return neighbours;
        }
Exemplo n.º 2
0
        /// <summary>
        /// Handles the Click event of the btnGenerateBoard control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        private void btnGenerateBoard_Click(object sender, EventArgs e)
        {
            int boardSize = int.Parse(txtBoardSize.Text);
            int numOfMen = int.Parse(txtNumOfMen.Text);
            int numOfWomen = int.Parse(txtNumOfWomen.Text);
            m_numOfGenerations = int.Parse(cmbNumOfGenerations.Text);

            var board = new Board(boardSize);

            BoardStrategyParameters parameters = GetStrategyParameters();
            IBoardStrategy strategy = BoardStrategyFactory.CreateStrategy(parameters);

            m_boardManager = new BoardManager(board, strategy);
            m_boardManager.PopulateBoard(numOfMen, numOfWomen);

            m_boardPanels = new Panel[boardSize, boardSize];

            InitializeBoardGraphics(m_boardManager.Board);

            btnRunAutomata.Enabled = true;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Redraws the board graphics.
        /// </summary>
        /// <param name="board">The board.</param>
        private void RedrawBoardGraphics(Board board)
        {
            for (int i = 0; i < board.Size; i++)
            {

                for (int j = 0; j < board.Size; j++)
                {
                    m_boardPanels[i, j].BackgroundImage = GetCellImage(board[i, j]);
                    m_boardPanels[i, j].BackColor = GelCellBackColor(board[i, j]);

                }

            }
            splitContainer1.Panel2.Refresh();
        }
Exemplo n.º 4
0
        /// <summary>
        /// Draws the board.
        /// </summary>
        /// <param name="board">The board.</param>
        /// <exception cref="System.NotImplementedException"></exception>
        private void InitializeBoardGraphics(Board board)
        {
            int cellSize = BoardWidthInPixel/board.Size;

            splitContainer1.Panel2.Controls.Clear();

            for (int i = 0; i < board.Size; i++)
            {

                for (int j = 0; j < board.Size; j++)
                {
                    var panel = new Panel
                    {
                        Size = new Size(cellSize, cellSize),
                        Location = new Point(BoardXOffset + (cellSize * i) , BoardYOffset + (cellSize * j)),
                        BackgroundImage = GetCellImage(board[i, j]),
                        BackgroundImageLayout = ImageLayout.Stretch,
                        BackColor = GelCellBackColor(board[i,j]),
                        BorderStyle = BorderStyle.FixedSingle,

                    };

                    splitContainer1.Panel2.Controls.Add(panel);
                    m_boardPanels[i, j] = panel;

                }

            }

            lblAverageHappiness.Text = "0";
            lblCurrHappiness.Text = "0";
            lblGenerationNum.Text = "0";
        }
 public void CalculateNextBoardState()
 {
     m_board = m_startegy.CalculateNextBoardState(m_board);
     m_totalGenerationsCalculated++;
     m_totalGenerationsHappiness += GetCurrentHappinessScore();
 }
 public BoardManager(Board board, IBoardStrategy strategy)
 {
     m_board = board;
     m_startegy = strategy;
     m_rand = new Random(DateTime.Now.Millisecond);
 }
        /// <summary>
        /// Calculates the state of the next board.
        /// </summary>
        /// <param name="board">The board.</param>
        /// <returns></returns>
        public Board CalculateNextBoardState(Board board)
        {
            var nextGenerationBoard = new Board(board.Size);

            for (int i = 0; i < board.Size; i++)
            {
                for (int j = 0; j < board.Size; j++)
                {
                    Cell currGenerationCell = board[i, j];
                    Cell nextGenerationCell = nextGenerationBoard[i, j];

                    if (nextGenerationCell.State != CellState.Empty /*Already calculated*/ || currGenerationCell.State == CellState.Empty) continue;

                    if (currGenerationCell.State != CellState.Couple) //A single cell, try to find spouses
                    {

                        Cell spouseCell = FindSpouseForSingleHumanCell(i, j, board, nextGenerationBoard);

                        if (spouseCell != null) // Found a spouse, create a couple
                        {
                            Human spouse = spouseCell.GetOppositeSexHuman(currGenerationCell.Humans[0].Sex);

                            Human human = currGenerationCell.Humans[0].Clone();

                            if (m_enableMemory) //If memory is enable, save spouses memory
                            {
                                human.BestCharacterDiffMemory = Math.Abs(spouse.Character - human.Character);
                            }

                            nextGenerationCell.Humans.Add(human);
                            nextGenerationCell.Humans.Add(spouse.Clone());

                            Tuple<int, int> spouseIndexes = board.FindCellIndexes(spouseCell);

                            if (spouseCell.State == CellState.Couple) //Create the single human cell in the next state board
                            {
                                spouseCell.Humans.Remove(spouse);
                                nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].Humans.Add(spouseCell.Humans[0].Clone());
                            }

                            board[spouseIndexes.Item1, spouseIndexes.Item2] = new Cell();
                            board[i, j] = new Cell();

                        }
                        else //Didn't find a spouse, try to move the human
                        {
                            MoveCell(board, nextGenerationBoard, i, j);

                        }

                    }
                    else //The cell has a couple
                    {
                        Cell spouse = FindBetterSpouseForCoupleCell(i, j, board);

                        if (spouse != null) //Found a better spouse, generate the new couple and new single
                        {
                            Tuple<int, int> spouseIndexes = board.FindCellIndexes(spouse);

                            if (spouse.State == CellState.Man)
                            {
                                //The new couple
                                nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].Humans.Add(spouse.Male.Clone());
                                nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].Humans.Add(board[i, j].Female.Clone());

                                //The new single
                                nextGenerationBoard[i, j].Humans.Add(board[i, j].Male.Clone());

                            }
                            else //Woman
                            {
                                //The new couple
                                nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].Humans.Add(spouse.Female.Clone());
                                nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].Humans.Add(board[i, j].Male.Clone());

                                //The new single
                                nextGenerationBoard[i, j].Humans.Add(board[i, j].Female.Clone());
                            }

                            //Clear the couple and the new spouse cells from the original board
                            board[i, j] = new Cell();
                            board[spouseIndexes.Item1, spouseIndexes.Item2] = new Cell();

                        }

                        else //Didn't find a better spouse, try to move the couple
                        {
                            MoveCell(board, nextGenerationBoard, i, j);

                        }

                    }

                }

            }

            return nextGenerationBoard;
        }
        /// <summary>
        /// Randomly Moves a cell on the board5.
        /// </summary>
        /// <param name="board">The board.</param>
        /// <param name="nextGenBoard">The next state board.</param>
        /// <param name="i">The i.</param>
        /// <param name="j">The j.</param>
        private void MoveCell(Board board, Board nextGenBoard, int i, int j)
        {
            Tuple<int, int> coordinates = GenerateRandomMoveCoordinates(i, j, board, nextGenBoard);

            if (coordinates != null)
            {
                nextGenBoard[coordinates.Item1, coordinates.Item2] = board[i, j].Clone();
            }
            else
            {
                nextGenBoard[i, j] = board[i, j].Clone(); ;
            }

            board[i, j] = new Cell();
        }
        /// <summary>
        /// Finds the spouse for single human cell.
        /// </summary>
        /// <param name="i">The i.</param>
        /// <param name="j">The j.</param>
        /// <param name="board">The board.</param>
        /// <returns></returns>
        private Cell FindSpouseForSingleHumanCell(int i, int j, Board board, Board nextGenerationBoard)
        {
            Human human = board[i, j].Humans[0];
            List<Cell> neighbours = GetCellNeighbours(i, j, board);

            //Filter only optional spouses
            neighbours = neighbours.Where(n => n.State != CellState.Empty &&
                                          n.GetOppositeSexHuman(human.Sex) != null).ToList();

            //Choose the best spouse
            var spouses = from neighbour in neighbours
                          let charDiff = Math.Abs(neighbour.GetOppositeSexHuman(human.Sex).Character - human.Character)
                          where (!m_enableMemory || charDiff < human.BestCharacterDiffMemory) &&
                                (m_maxCharacterDiffForCoupling == null ||
                                (charDiff <= m_maxCharacterDiffForCoupling && charDiff < neighbour.CharacterDiff))
                          orderby charDiff ascending
                          select neighbour;

            //Filter couple spouse where the couple cell was already calculated in the next generation board, to avoid override
            spouses = from spouse in spouses
                      let spouseIndexes = board.FindCellIndexes(spouse)
                      where spouse.State != CellState.Couple || nextGenerationBoard[spouseIndexes.Item1, spouseIndexes.Item2].State == CellState.Empty
                      select spouse;

            return spouses.FirstOrDefault(); //The best spouse
        }
        /// <summary>
        /// Finds the better spouse for couple cell.
        /// </summary>
        /// <param name="i">The i.</param>
        /// <param name="j">The j.</param>
        /// <param name="board">The board.</param>
        /// <returns></returns>
        private Cell FindBetterSpouseForCoupleCell(int i, int j, Board board)
        {
            Cell cell = board[i, j];
            List<Cell> neighbours = GetCellNeighbours(i, j, board);

            //Consider only non-empty cells
            neighbours = neighbours.Where(n => n.State != CellState.Empty).ToList();

            int coupleCharDiff = Math.Abs(cell.Humans[0].Character - cell.Humans[1].Character);

            var betterSpouses = from neighbour in neighbours
                                let charDiff = neighbour.Humans[0].Sex == Sex.Female ? Math.Abs(cell.Male.Character - neighbour.Humans[0].Character) : Math.Abs(cell.Female.Character - neighbour.Humans[0].Character)
                                where (neighbour.State == CellState.Man || neighbour.State == CellState.Woman) && charDiff < coupleCharDiff
                                select neighbour;

            return betterSpouses.FirstOrDefault();
        }
        /// <summary>
        /// Gets the cell neighbours.
        /// </summary>
        /// <param name="i">The i.</param>
        /// <param name="j">The j.</param>
        /// <param name="board">The board.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentException">Indexes must be a positive integer</exception>
        public virtual List<Cell> GetCellNeighbours(int i, int j, Board board)
        {
            int size = board.Size;

            if (i < 0 || j < 0)
            {
                throw new ArgumentException("Indexes must be a positive integer");
            }

            if (i >= size || j >= size)
            {
                throw new ArgumentException("Indexes must be less than board size:" + size);
            }

            var neighbours = new List<Cell>();

            if (i > 0) //Add top neighbours
            {
                neighbours.Add(board[i - 1, j]);

                if (j < size - 1)
                {
                    neighbours.Add(board[i - 1, j + 1]);
                }

                if (j > 0)
                {
                    neighbours.Add(board[i - 1, j - 1]);

                }
            }

            if (i < size - 1) //Add bottom neighbours
            {
                neighbours.Add(board[i + 1, j]);

                if (j < size - 1)
                {
                    neighbours.Add(board[i + 1, j + 1]);
                }

                if (j > 0)
                {
                    neighbours.Add(board[i + 1, j - 1]);

                }

            }

            //Add side neighbours
            if (i > 0)
            {
                neighbours.Add(board[i - 1, j]);
            }

            if (i < size - 1)
            {
                neighbours.Add(board[i + 1, j]);
            }

            return neighbours;
        }
        /// <summary>
        /// Generates the random move coordinates.
        /// </summary>
        /// <param name="i">The i.</param>
        /// <param name="j">The j.</param>
        /// <param name="board">The board.</param>
        /// <returns>Returns the new random coordinates or null if couldn't find any</returns>
        public Tuple<int, int> GenerateRandomMoveCoordinates(int i, int j, Board board, Board nextGenBoard)
        {
            int iRnd, jRnd;

            int tries = 0;

            do
            {
                iRnd = GenerateRandomMoveCoordinate(i, board.Size);
                jRnd = GenerateRandomMoveCoordinate(j, board.Size);

                tries++;

            } while ((board[iRnd, jRnd].State != CellState.Empty || nextGenBoard[iRnd, jRnd].State != CellState.Empty) && tries < MaxRandomMoveTries);

            if (tries == MaxRandomMoveTries) //Couldn't find an empty cell, so stay at the same cell.
            {
                return null;
            }
            else
            {
                return new Tuple<int, int>(iRnd, jRnd);
            }
        }