玩无限消乐的设计示例（智能篇）优先搜寻算法

最新推荐文章于 2023-03-22 17:10:37 发布

智者知已应修善业

最新推荐文章于 2023-03-22 17:10:37 发布

阅读量529

点赞数

本文链接：https://blog.csdn.net/xianfajushi/article/details/53066367

版权

智能搜寻中把特效配对搜寻优先排在前面,从而优先进行提示,提示存入数组中,从特效开始直到普通配对提示循环闪烁显示.

        private void 优先搜寻(bool 控 = true)
        {
            int 寻 = 0, 反寻 = 0, 行列 = 0, 数据 = 0, 同连 = 0, 搜1 = 0, 搜2 = 0, 搜3 = 0, 搜4 = 0,
                行数 = 玩无限消乐.RowCount, 列数 = 玩无限消乐.ColumnCount;
            添集合 = false;
            Func<int, int, DataGridViewCell> 记录单元 = (行序, 列序) => { return 玩无限消乐.Rows[行序].Cells[列序]; };
            //Action<int, int> 配对搜寻 = (主数据, 辅数据) => { new Thread(() => { 智能配对(主数据, 辅数据); 智能配对(主数据, 辅数据, false); }).Start(); };
            //Action<int, DataGridViewCell, bool> 添加数据 = (辅数据, 单元, 选) =>
            //{
            //    if ((int)单元.Tag != 0)
            //    {
            //        bool 判 = true;
            //        foreach (DataGridViewCell 元素 in 最优集合)
            //            if (元素 != null && 元素.ColumnIndex == 单元.ColumnIndex && 单元.RowIndex == 元素.RowIndex) { 判 = false; break; }
            //        if (判) { if (选) 最优集合.Add(单元); else 最优集合.Insert(0, 单元); 配对搜寻((int)单元.Tag, 辅数据); }
            //    }
            //};
            Action<int> 智能优先 = (辅数据) => { 添加智能(辅数据, 记录单元((控 ? 寻 : 行列) + (控 ? 1 : 0), (控 ? 行列 : 寻) + (控 ? 0 : 1)), false, true); };
            Action<int> 智能优反 = (辅数据) => { 添加智能(辅数据, 记录单元(控 ? 寻 - 2 : 行列, 控 ? 行列 : 寻 - 2), false, true); };
            Action<DataGridViewCell> 记录数据 = (单元) =>
            { 跟踪记录("最优搜寻：" + 单元.RowIndex.ToString("00行；") + 单元.ColumnIndex.ToString("00列")); };
            while (行列 < (控 ? 列数 : 行数))
            {
                int 搜数据 = (int)记录单元(控 ? 寻 : 行列, 控 ? 行列 : 寻).Tag;
                反寻 = 寻 == 2 ? 2 : 寻 > 2 ? 3 : 0;
                if (控 && 行列 > 0 && 行列 < 列数 - 1 && 寻 < 行数 - 2)/*搜寻梅花*/
                {
                    搜1 = (int)记录单元(寻, 行列).Tag;
                    搜2 = (int)记录单元(寻 + 1, 行列 - 1).Tag;
                    搜3 = (int)记录单元(寻 + 1, 行列 + 1).Tag;
                    搜4 = (int)记录单元(寻 + 2, 行列).Tag;
                    if (搜1 == 搜2 && 搜2 == 搜3 && 搜3 == 搜4 && 搜1 != 0)
                        添加智能(搜1, 记录单元(寻 + 1, 行列), false, true);
                }
                if (数据 != 搜数据 || 搜数据 == 0)
                {
                    同连 = 反寻 = 0; 数据 = 搜数据;
                }
                else
                {
                    if (寻 < (控 ? 行数 : 列数) - 1)/*搜寻飞翔*/
                    {
                        if (行列 > 1)
                        {/*行+1，列-1-2；列+1，行-1-2*/
                            搜1 = (int)记录单元((控 ? 寻 : 行列) + (控 ? 1 : -1), (控 ? 行列 : 寻) + (控 ? -1 : 1)).Tag;
                            搜2 = (int)记录单元((控 ? 寻 : 行列) + (控 ? 1 : -2), (控 ? 行列 : 寻) + (控 ? -2 : 1)).Tag;
                        }
                        if (数据 == 搜1 && 搜1 == 搜2)
                            智能优先(数据);
                        if (行列 < (控 ? 列数 : 行数) - 2)
                        {/*行+1，列+1+2；列+1，行+1+2*/
                            搜3 = (int)记录单元((控 ? 寻 : 行列) + 1, (控 ? 行列 : 寻) + 1).Tag;
                            搜4 = (int)记录单元((控 ? 寻 : 行列) + (控 ? 1 : 2), (控 ? 行列 : 寻) + (控 ? 2 : 1)).Tag;
                        }
                        if (数据 == 搜3 && 搜3 == 搜4)
                            智能优先(数据);
                        if (反寻 > 0 && 行列 > 1)
                        {/*行-2，列-1-2；列-2，行-1-2*/
                            搜1 = (int)记录单元((控 ? 寻 : 行列) + (控 ? -2 : -1), (控 ? 行列 : 寻) + (控 ? -1 : -2)).Tag;
                            搜2 = (int)记录单元((控 ? 寻 : 行列) - 2, (控 ? 行列 : 寻) - 2).Tag;
                            if (数据 == 搜1 && 搜1 == 搜2)
                                智能优反(数据);
                            if (行列 < (控 ? 列数 : 行数) - 2)
                            {/*行-2，列+1+2；列-2，行+1+2*/
                                搜3 = (int)记录单元((控 ? 寻 : 行列) + (控 ? -2 : 1), (控 ? 行列 : 寻) + (控 ? 1 : -2)).Tag;
                                搜4 = (int)记录单元((控 ? 寻 : 行列) + (控 ? -2 : 2), (控 ? 行列 : 寻) + (控 ? 2 : -2)).Tag;
                            }
                            if (数据 == 搜3 && 搜3 == 搜4)
                                智能优反(数据);
                        }
                    }
                    if (寻 < (控 ? 行数 : 列数) - 2)/*搜寻连珠*/
                    {
                        搜1 = (int)记录单元(控 ? 寻 + 2 : 行列, 控 ? 行列 : 寻 + 2).Tag;
                        if (数据 == 搜1 && 搜1 != 0)
                            添加智能(数据, 记录单元(控 ? 寻 + 1 : 行列, 控 ? 行列 : 寻 + 1), true, true);
                    }
                    if (反寻 > 0 && 寻 < (控 ? 行数 : 列数))/*搜寻连珠*/
                    {
                        搜1 = (int)记录单元(控 ? 寻 - 反寻 : 行列, 控 ? 行列 : 寻 - 反寻).Tag;
                        if (数据 == 搜1 && 搜1 != 0)
                            添加智能(数据, 记录单元(控 ? 寻 - 反寻 + 1 : 行列, 控 ? 行列 : 寻 - 反寻 + 1), true, true);
                    }
                    if (寻 < (控 ? 行数 : 列数) - 1 && 行列 > 0 && 行列 < (控 ? 列数 : 行数) - 1)/*搜寻玉叉*/
                    {
                        搜1 = (int)记录单元((控 ? 寻 : 行列) + (控 ? 1 : -1), (控 ? 行列 : 寻) + (控 ? -1 : 1)).Tag;
                        搜2 = (int)记录单元((控 ? 寻 : 行列) + 1, (控 ? 行列 : 寻) + 1).Tag;
                        if (数据 == 搜1 && 搜1 == 搜2)
                            智能优先(数据);
                        if (反寻 > 0)
                        {
                            搜1 = (int)记录单元((控 ? 寻 : 行列) + (控 ? -2 : -1), (控 ? 行列 : 寻) + (控 ? -1 : -2)).Tag;
                            搜2 = (int)记录单元((控 ? 寻 : 行列) + (控 ? -2 : 1), (控 ? 行列 : 寻) + (控 ? 1 : -2)).Tag;
                            if (数据 == 搜1 && 搜1 == 搜2)
                                智能优反(数据);
                        }
                    }
                }

                if (++寻 >= (控 ? 行数 : 列数))
                { ++行列; 同连 = 寻 = 数据 = 0; /*内环*/}
                //Application.DoEvents();
            }
            //foreach (DataGridViewCell 最优 in 最优集合)
            //    记录数据(最优);
            //return 最优集合;
        }

这个游戏写到这里基本结束,也无心再写下去了,更无心去做优化,大约可以偶尔玩玩即可.之下罗列出各种配对示意图: