細胞自動機

今天發奇想，想試試康威生命游戲。規則非常簡單：

每個細胞有兩種狀態 - 存活或死亡，每個細胞與以自身為中心的周圍八格細胞產生互動。（如圖，黑色為存活，白色為死亡）
當前細胞為存活狀態時，當周圍低於2個（不包含2個）存活細胞時， 該細胞變成死亡狀態。（模擬生命數量稀少）
當前細胞為存活狀態時，當周圍有2個或3個存活細胞時， 該細胞保持原樣。
當前細胞為存活狀態時，當周圍有3個以上的存活細胞時，該細胞變成死亡狀態。（模擬生命數量過多）
當前細胞為死亡狀態時，當周圍有3個存活細胞時，該細胞變成存活狀態。 （模擬繁殖）

用C#實現起來也是非常順滑，只在那個嵌套for循環的地方為了避免O(n*8)復雜度過大做了一個catch處理。一個winform就可以了：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Cell
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.Width = m_kXCount * m_kGridSize + m_kGridSize;
            this.Height = m_kYCount * m_kGridSize + m_kGridSize;
            DoubleBuffered = true;
            StartPosition = FormStartPosition.CenterScreen;
            BackColor = Color.White;
            initGrids();
            initTimer();
        }

        //網格對象
        class Grid
        {
            public Rectangle rect;
            public bool alive;
            public bool next;
            public Point pos;//topleft
        }

        const int m_kGridSize = 20;
        const int m_kXCount = 100;
        const int m_kYCount = 60;
        const int m_kAntCount = 1;

        Grid[,] m_allGrids = new Grid[m_kXCount, m_kYCount];
        void initGrids()
        {
            for (int x = 0; x < m_kXCount; x++)
            {
                for (int y = 0; y < m_kYCount; y++)
                {
                    m_allGrids[x, y] = new Grid
                    {
                        alive = false,
                        pos = new Point(x, y),
                        rect = new Rectangle(x * m_kGridSize, y * m_kGridSize, m_kGridSize, m_kGridSize),
                    };
                }
            }
        }

        //細胞
        List<Grid> m_allCells = new List<Grid>();

        //定時器
        Timer m_timer = new Timer();
        void initTimer()
        {
            m_timer.Interval = 100;//螞蟻移動速度
            m_timer.Tick += onTimerTick;
            m_timer.Enabled = false;
        }

        Size[] m_8offset = new Size[8]
        {
            new Size(-1,-1),
            new Size(0,-1),
            new Size(1,-1),
            new Size(-1,0),
            new Size(1,0),
            new Size(-1,1),
            new Size(0,1),
            new Size(1,1)
        };

        private void onTimerTick(object sender, EventArgs e)
        {
            //每個細胞有兩種狀態 - 存活或死亡，每個細胞與以自身為中心的周圍八格細胞產生互動。（如圖，黑色為存活，白色為死亡）
            //當前細胞為存活狀態時，當周圍低於2個（不包含2個）存活細胞時， 該細胞變成死亡狀態。（模擬生命數量稀少）
            //當前細胞為存活狀態時，當周圍有2個或3個存活細胞時， 該細胞保持原樣。
            //當前細胞為存活狀態時，當周圍有3個以上的存活細胞時，該細胞變成死亡狀態。（模擬生命數量過多）
            //當前細胞為死亡狀態時，當周圍有3個存活細胞時，該細胞變成存活狀態。 （模擬繁殖）

            List<Grid> newCells = new List<Grid>();
            List<Grid> checkedCell = new List<Grid>();
            foreach(var cell in m_allCells)
            {
                int cnt = 0;
                foreach(var s in m_8offset)
                {
                    var p = cell.pos + s;
                    if (p.X < 0) p.X = m_kXCount - 1;
                    if (p.Y < 0) p.Y = m_kYCount - 1;
                    if (p.X == m_kXCount) p.X = 0;
                    if (p.Y == m_kYCount) p.Y = 0;

                    var _cell = m_allGrids[p.X, p.Y];
                    if (_cell.alive)
                    {
                        cnt++;
                    }
                    else
                    {
                        if (checkedCell.Contains(_cell))
                            continue;

                        checkedCell.Add(_cell);

                        //死亡狀態的細胞
                        int _cnt = 0;
                        foreach(var _s in m_8offset)
                        {
                            var _p = _cell.pos + _s;
                            if (_p.X < 0) _p.X = m_kXCount - 1;
                            if (_p.Y < 0) _p.Y = m_kYCount - 1;
                            if (_p.X == m_kXCount) _p.X = 0;
                            if (_p.Y == m_kYCount) _p.Y = 0;

                            var __cell = m_allGrids[_p.X, _p.Y];
                            if (__cell.alive)
                            {
                                _cnt++;
                            }
                        }
                        if (_cnt == 3)
                        {
                            _cell.next = true;
                            newCells.Add(_cell);
                        }
                    }
                }
                if (cnt < 2 || cnt > 3)
                    cell.next = false;
                else
                    cell.next = true;
            }
            foreach(var cell in m_allCells)
            {
                cell.alive = cell.next;
            }
            foreach(var cell in newCells)
            {
                cell.alive = cell.next;
            }
            m_allCells.RemoveAll(c => !c.alive);
            m_allCells.AddRange(newCells);
            Invalidate();
        }

        //鼠標選擇活細胞
        protected override void OnMouseClick(MouseEventArgs e)
        {
            base.OnMouseClick(e);
            if (m_isRunning) return;
            //計算位置
            int x = e.X / m_kGridSize;
            int y = e.Y / m_kGridSize;
            var grid = m_allGrids[x, y];
            grid.alive = true;
            m_allCells.Add(grid);

            Invalidate();
        }

        bool m_isRunning = false;
        //鍵盤控制啟動暫停
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            if (e.KeyCode == Keys.Space)
            {
                m_isRunning = !m_isRunning;
                m_timer.Enabled = !m_timer.Enabled;
            }
        }

        Pen m_gridPen = new Pen(Color.Black, 1);
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            var g = e.Graphics;

            //繪制網格
            for (int x = 0; x < m_kXCount; x++)
            {
                for (int y = 0; y < m_kYCount; y++)
                {
                    var grid = m_allGrids[x, y];
                    if (grid.alive)
                    {
                        g.FillRectangle(Brushes.Brown, grid.rect);
                    }
                    g.DrawRectangle(m_gridPen, grid.rect);
                }
            }
        }

    }
}

定時器默認是關閉的，用鼠標點選一個初始形狀作為種子，按空格鍵開始/暫停。我嘗試了一個3*3的十字，每次死循環之后按空格暫停，在中間繼續畫十字，可以得到非常有趣的圖案。盡管嘗試吧。。