Пример #1
0
        private int _OpenGrids_compfunc(GridST g1, GridST g2)
        {
            bool flag = g1.F < g2.F;
            int  result;

            if (flag)
            {
                result = -1;
            }
            else
            {
                bool flag2 = g1.F == g2.F;
                if (flag2)
                {
                    bool flag3 = g1.H < g2.H;
                    if (flag3)
                    {
                        result = -1;
                        return(result);
                    }
                }
                result = 1;
            }
            return(result);
        }
Пример #2
0
        private int _OpenGrids_compfunc(GridST g1, GridST g2)
        {
            if (g1.F < g2.F)
            {
                return(-1);
            }
            else if (g1.F == g2.F)
            {
                if (g1.H < g2.H)
                {
                    return(-1);
                }
            }

            return(1);
        }
Пример #3
0
        public List <GridST> findPath(Vec2 start, Vec2 end)
        {
            bool          flag = !this.IsWalkAble((float)((int)end.x), (float)((int)end.y));
            List <GridST> result;

            if (flag)
            {
                end = this._getWalkabelEnd(start, end);
                bool flag2 = end == null;
                if (flag2)
                {
                    GameTools.PrintNotice("end point not walkable!");
                    result = null;
                    return(result);
                }
            }
            bool flag3 = start.x == end.x && start.y == end.y;

            if (flag3)
            {
                result = new List <GridST>();
            }
            else
            {
                int                       num         = (int)((long)this._curMapConf["param"]["width"]._int / 32L);
                int                       num2        = (int)((long)this._curMapConf["param"]["height"]._int / 32L);
                List <GridST>             list        = new List <GridST>();
                Dictionary <uint, GridST> dictionary  = new Dictionary <uint, GridST>();
                Dictionary <int, int>     dictionary2 = new Dictionary <int, int>();
                list.Add(new GridST
                {
                    x        = (float)((int)start.x),
                    y        = (float)((int)start.y),
                    parent   = null,
                    G        = 0,
                    H        = 0,
                    F        = 0,
                    isCorner = false,
                    tile_idx = 0u
                });
                GridST gridST = null;
                while (list.Count > 0)
                {
                    GridST gridST2 = ArrayUtil.pop_priority_queue <GridST>(list, new ArrayUtil.CompareFunction <GridST>(this._OpenGrids_compfunc));
                    uint   key     = (uint)((int)gridST2.y << 9 | ((int)gridST2.x & 511));
                    dictionary2[(int)key] = 1;
                    for (int i = 0; i < 3; i++)
                    {
                        int  num3  = (int)(gridST2.y + (float)i - 1f);
                        bool flag4 = num3 < 0 || num3 >= num2;
                        if (!flag4)
                        {
                            uint num4 = (uint)((uint)num3 << 9);
                            for (int j = 0; j < 3; j++)
                            {
                                int  num5  = (int)(gridST2.x + (float)j - 1f);
                                bool flag5 = num5 < 0 || num5 >= num;
                                if (!flag5)
                                {
                                    uint num6  = num4 | (uint)(num5 & 511);
                                    bool flag6 = dictionary2.ContainsKey((int)num6);
                                    if (!flag6)
                                    {
                                        int  key2  = (int)num6;
                                        bool flag7 = this._CollideInfoEx[key2] == 1u || (this._BlockZoneInfo.ContainsKey((int)num6) && this._BlockZoneInfo[(int)num6] > 0u);
                                        if (flag7)
                                        {
                                            dictionary2[(int)num6] = 1;
                                        }
                                        else
                                        {
                                            int  num7     = gridST2.G + 1;
                                            bool isCorner = false;
                                            bool flag8    = gridST2.x != (float)num5 && gridST2.y != (float)num3;
                                            if (flag8)
                                            {
                                                num7     = gridST2.G + 2;
                                                isCorner = true;
                                            }
                                            int  num8  = (int)(Math.Abs((float)num3 - end.y) + Math.Abs((float)num5 - end.x));
                                            int  num9  = num7 + num8;
                                            bool flag9 = dictionary.ContainsKey(num6);
                                            if (flag9)
                                            {
                                                GridST gridST3 = dictionary[num6];
                                                bool   flag10  = num9 < gridST3.F || (num9 == gridST3.F && num8 < gridST3.H);
                                                if (flag10)
                                                {
                                                    gridST3.F        = num9;
                                                    gridST3.H        = num8;
                                                    gridST3.G        = num7;
                                                    gridST3.parent   = gridST2;
                                                    gridST3.isCorner = isCorner;
                                                    gridST3.tile_idx = num6;
                                                }
                                            }
                                            else
                                            {
                                                dictionary[num6] = new GridST
                                                {
                                                    x        = (float)num5,
                                                    y        = (float)num3,
                                                    parent   = gridST2,
                                                    G        = num7,
                                                    H        = num8,
                                                    F        = num9,
                                                    isCorner = isCorner,
                                                    tile_idx = num6
                                                };
                                                ArrayUtil.push_priority_queue <GridST>(list, dictionary[num6], new ArrayUtil.CompareFunction <GridST>(this._OpenGrids_compfunc));
                                                bool flag11 = (float)num5 == end.x && (float)num3 == end.y;
                                                if (flag11)
                                                {
                                                    gridST = dictionary[num6];
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            bool flag12 = gridST != null;
                            if (flag12)
                            {
                                break;
                            }
                        }
                    }
                    bool flag13 = gridST != null;
                    if (flag13)
                    {
                        break;
                    }
                }
                bool flag14 = gridST == null;
                if (flag14)
                {
                    result = null;
                }
                else
                {
                    List <GridST> list2 = new List <GridST>();
                    while (gridST != null)
                    {
                        list2.Add(new GridST
                        {
                            x        = gridST.x,
                            y        = gridST.y,
                            parent   = gridST.parent,
                            G        = gridST.G,
                            H        = gridST.H,
                            F        = gridST.F,
                            isCorner = gridST.isCorner,
                            tile_idx = gridST.tile_idx
                        });
                        gridST = gridST.parent;
                    }
                    result = list2;
                }
            }
            return(result);
        }
Пример #4
0
        public List <GridST> findPath(Vec2 start, Vec2 end)
        {
            if (!this.IsWalkAble((int)end.x, (int)end.y))
            {
                //如果目标点不能行走,以此取目标点和出发点连线上的点,改目标点为最接近目标点的可行走点,开始寻路

                end = this._getWalkabelEnd(start, end);

                if (end == null)
                {
                    GameTools.PrintNotice("end point not walkable!");
                    return(null);
                }
            }

            if (start.x == end.x && start.y == end.y)
            {
                return(new List <GridST>());
            }



            int map_width  = (int)(_curMapConf["param"]["width"]._int / GameConstant.GEZI);
            int map_height = (int)(_curMapConf["param"]["height"]._int / GameConstant.GEZI);

            List <GridST>             Open_Grids     = new List <GridST>();
            Dictionary <uint, GridST> Open_Grids_map = new Dictionary <uint, GridST>();
            Dictionary <int, int>     Grids_hex_mark = new Dictionary <int, int>();

            GridST st = new GridST();

            st.x        = (int)start.x;
            st.y        = (int)start.y;
            st.parent   = null;
            st.G        = 0;
            st.H        = 0;
            st.F        = 0;
            st.isCorner = false;
            st.tile_idx = 0;

            Open_Grids.Add(st);

            GridST end_tile = null;
            int    i        = 0;
            int    j        = 0;

            while (Open_Grids.Count > 0)
            {
                GridST cur_tile = ArrayUtil.pop_priority_queue(Open_Grids, _OpenGrids_compfunc);

                uint tile_idx = (uint)(((int)(cur_tile.y)) << 9 | ((int)(cur_tile.x)) & 0x000001ff);

                Grids_hex_mark[(int)tile_idx] = 1; // 标记为已走

                //debug.dbginfo("cur node x["+cur_tile.x+"] y["+cur_tile.y+"]");

                for (i = 0; i < 3; ++i)
                {
                    int edge_tile_y = (int)(cur_tile.y + i - 1);

                    if (edge_tile_y < 0 || edge_tile_y >= map_height) // 坐标不合法
                    {
                        continue;
                    }

                    uint edge_tile_idx_y = (uint)(edge_tile_y << 9);
                    for (j = 0; j < 3; ++j)
                    {
                        int edge_tile_x = (int)(cur_tile.x + j - 1);

                        if (edge_tile_x < 0 || edge_tile_x >= map_width) // 坐标不合法
                        {
                            continue;
                        }

                        uint edge_tile_idx = (uint)(edge_tile_idx_y | (uint)(edge_tile_x & 0x000001ff));


                        if (Grids_hex_mark.ContainsKey((int)edge_tile_idx)) // 不能走,或已判断过
                        {
                            continue;
                        }
                        int index = (int)edge_tile_idx;
                        //if( index > _CollideInfoEx.Count -1 )
                        //{
                        //	//GameTools.PrintError( "CollideInfoEx info err!"  );
                        //	continue;
                        //}

                        if ((_CollideInfoEx[index] == 1) ||
                            (this._BlockZoneInfo.ContainsKey((int)edge_tile_idx) &&
                             this._BlockZoneInfo[(int)edge_tile_idx] > 0))
                        // 格子不可行走
                        {
                            Grids_hex_mark[(int)edge_tile_idx] = 1;                             // 标记为 已判断过,不能走
                            continue;
                        }

                        // 计算 F, G, H
                        int  G        = cur_tile.G + 1; // 上下左右 +1
                        bool isCorner = false;
                        if (cur_tile.x != edge_tile_x && cur_tile.y != edge_tile_y)
                        {
                            G        = cur_tile.G + 2; // 边角 +2
                            isCorner = true;
                        }


                        int H = (int)(Math.Abs(edge_tile_y - end.y) + Math.Abs(edge_tile_x - end.x));
                        int F = G + H;

                        if (Open_Grids_map.ContainsKey(edge_tile_idx))
                        {
                            // 已在开放格子列表中
                            //dbg_str += "founded!";
                            GridST edge_tile = Open_Grids_map[edge_tile_idx];
                            if (F < edge_tile.F || (F == edge_tile.F && H < edge_tile.H))
                            {
                                // 新路径更佳
                                edge_tile.F        = F;
                                edge_tile.H        = H;
                                edge_tile.G        = G;
                                edge_tile.parent   = cur_tile;
                                edge_tile.isCorner = isCorner;
                                edge_tile.tile_idx = edge_tile_idx;
                            }
                        }
                        else
                        {
                            // 新格子

                            GridST stt = new GridST();
                            stt.x        = edge_tile_x;
                            stt.y        = edge_tile_y;
                            stt.parent   = cur_tile;
                            stt.G        = G;
                            stt.H        = H;
                            stt.F        = F;
                            stt.isCorner = isCorner;
                            stt.tile_idx = edge_tile_idx;
                            Open_Grids_map[edge_tile_idx] = stt;


                            ArrayUtil.push_priority_queue(Open_Grids, Open_Grids_map[edge_tile_idx], _OpenGrids_compfunc);


                            if (edge_tile_x == end.x && edge_tile_y == end.y)
                            {
                                end_tile = Open_Grids_map[edge_tile_idx];
                                break;
                            }
                        }
                    }

                    if (end_tile != null)
                    {
                        // 找到了
                        break;
                    }
                }

                if (end_tile != null)
                {
                    // 找到了
                    break;
                }
            }



            if (end_tile == null)
            {
                return(null);
            }

            List <GridST> path_ary = new List <GridST>();

            for (; end_tile != null;)
            {
                GridST ast = new GridST();
                ast.x        = end_tile.x;
                ast.y        = end_tile.y;
                ast.parent   = end_tile.parent;
                ast.G        = end_tile.G;
                ast.H        = end_tile.H;
                ast.F        = end_tile.F;
                ast.isCorner = end_tile.isCorner;
                ast.tile_idx = end_tile.tile_idx;

                path_ary.Add(ast);

                end_tile = end_tile.parent;
            }

            return(path_ary);
        }