Esempio n. 1
0
    private static List <TilePosition> CalculateLinePath(List <TilePosition> aStarPath, bool[,] obstacleMap)
    {
        List <TilePosition> result = new List <TilePosition>();

        for (int i = 0; i < aStarPath.Count - 1;)
        {
            TilePosition start = aStarPath[i];
            if (i == 0)
            {
                result.Add(start);
            }
            for (int j = aStarPath.Count - 1; j > i; j--)
            {
                TilePosition        end  = aStarPath[j];
                List <TilePosition> line = LinearizationHelper.BresenhamLine(start, end);
                bool blocked             = false;
                foreach (TilePosition lineIndex in line)
                {
                    if (obstacleMap[lineIndex.Row, lineIndex.Column])
                    {
                        blocked = true;
                        break;
                    }
                }
                if (!blocked)
                {
                    result.Add(end);
                    i = j;
                }
                else
                {
                    if (j == i + 1)
                    {
                        result.Add(end);
                        return(result);
                    }
                }
            }
        }

        return(result);
    }
Esempio n. 2
0
    private static List <TilePosition> CalculateLinePath(List <TilePosition> aStarPath, bool[,] obstacleMap)
    {
        List <TilePosition> result = new List <TilePosition>();

        /*
         * Debug.Log("------------------------------------------");
         * foreach (TilePosition at in aStarPath)
         * {
         *      Debug.Log("astar pt is row:" + at.Row + "astar pt column is:" + at.Column);
         * }
         */
        List <TilePosition> needLinePath = new List <TilePosition>();

        needLinePath.Add(aStarPath[0]);
        for (int i = 1; i < aStarPath.Count; i++)
        {
            needLinePath.Add(aStarPath[i]);
            if (obstacleMap[aStarPath[i].Row, aStarPath[i].Column])
            {
                break;
            }
        }

        for (int i = 0; i < needLinePath.Count - 1;)
        {
            TilePosition start = needLinePath[i];
            if (i == 0)
            {
                result.Add(start);
            }
            for (int j = needLinePath.Count - 1; j > i; j--)
            {
                TilePosition        end  = needLinePath[j];
                List <TilePosition> line = LinearizationHelper.BresenhamLine(start, end);

                /*
                 * Debug.Log("line pt is:" + line.Count + ".start point row is:" + start.Row + "start point column is:" + start.Column +
                 *      ".end point row is:" + end.Row + "end point column is:" + end.Column);
                 * foreach (TilePosition lt in line)
                 * {
                 *      //Debug.Log("find the error");
                 *      Debug.Log("row is:" + lt.Row + ",column is:" + lt.Column);
                 * }
                 */
                bool blocked = false;
                foreach (TilePosition lineIndex in line)
                //for(int k = i==0 ? 1 : 0; k < line.Count; k ++)
                {
                    //TilePosition lineIndex = line[k];
                    if (obstacleMap[lineIndex.Row, lineIndex.Column])
                    {
                        //Debug.Log("**********************");
                        //Debug.Log(lineIndex.Row + " , " + lineIndex.Column);
                        blocked = true;
                        //Debug.Log("**********************");
                        break;
                    }
                }
                if (!blocked)
                {
                    result.Add(end);
                    i = j;
                }
                else
                {
                    if (j == i + 1)
                    {
                        result.Add(end);
                        return(result);
                    }
                }
            }
        }

        return(result);
    }