private void DrawHouse(PFCanvas canvas)
    {
        var scale = 0.5f;

        canvas.Save();

        canvas.SetCurrentTransform(
            Matrix4x4.Translate(new Vector2(0, Screen.height - 160)) *
            Matrix4x4.Scale(new Vector2(scale, scale))
            );
        canvas.SetLineWidth(10.0f * scale);
        canvas.SetStrokeStyle(Color.black);
        canvas.SetFillStyle(Color.black);
        canvas.SetLineJoin(PFLineJoin.Round);

        // Draw walls.
        canvas.StrokeRect(new Rect(75.0f, 140.0f, 150.0f, 110.0f));

        // Draw door.
        canvas.FillRect(new Rect(130.0f, 190.0f, 40.0f, 60.0f));

        // Draw roof.
        var path = new PFPath();

        path.MoveTo(new Vector2(50.0f, 140.0f));
        path.LineTo(new Vector2(150.0f, 60.0f));
        path.LineTo(new Vector2(250.0f, 140.0f));
        path.ClosePath();
        canvas.StrokePath(path);

        canvas.Restore();
    }
Пример #2
0
    void Update()
    {
        if (ranTests)
        {
            return;
        }

        // Just some smoke tests to make sure we don't segfault.
        var gState = GetComponent <GlobalStateScript>();

        if (!gState.IsPathfinderEnabled())
        {
            return;
        }

        var path = new PFPath();

        // We should be able to clone paths.
        path.Clone();

        var canvas = new PFCanvas(gState.GetFontContext(), new Vector2(10, 10));

        // We should be able to pass empty strings.
        canvas.FillText("", new Vector2(0, 0));

        ranTests = true;
        print("Successfully ran smoke tests.");
    }
Пример #3
0
    public void FillPath(PFPath path)
    {
        EnsureHandleIsValid();
        var pathHandleToConsume = path.PrepareToConsume();

        PF.PFCanvasFillPath(handle, pathHandleToConsume);
    }
Пример #4
0
    public override void Exit()
    {
        // 혹시나 못쓴 cost는 싹 써버리기
        owner.actionPointsRemain = Mathf.Max(owner.actionPointsRemain - _cost, 0);
        EventMgr.Instance.onUnitRunExit.Invoke(new UnitStateEvent(owner));

        _path = null;
    }
 private void drawCircles(PFCanvas canvas, Vector2 center)
 {
     for (int index = 0; index < CIRCLE_COUNT; index++)
     {
         var radius = (index + 1) * CIRCLE_SPACING * SCALE;
         var path   = new PFPath();
         path.Ellipse(center, new Vector2(radius, radius), 0, 0, Mathf.PI * 2.0f);
         canvas.StrokePath(path);
     }
 }
Пример #6
0
 public PFPath(PFPath targetToClone = null)
 {
     if (targetToClone != null)
     {
         handle = PF.PFPathClone(targetToClone.handle);
     }
     else
     {
         handle = PF.PFPathCreate();
     }
 }
Пример #7
0
 // Command를 할수 있는지 없는지만 검사합니다.
 // 생성자대용으로 사용합니다.
 public static bool CreateCommand(Unit unit, PFPath path, out MoveCommand moveCommand)
 {
     if (unit.actionPointsRemain >= unit.GetActionSlot(ActionType.Move).cost *path.Length)
     {
         moveCommand = new MoveCommand(path);
         return(true);
     }
     else
     {
         moveCommand = null;
         return(false);
     }
 }
    private void OnClickCubeCanGo(Cube cubeClicked)
    {
        // for wait state
        this.cubeClicked = cubeClicked;

        // chage state to wait state of unitRunExit, pathUpdateEnd Event
        ChangeStateToWaitState();

        // unit move
        PFPath pathToDest = unit.GetCube.paths.Find((p) => p.destination == cubeClicked);

        MoveCommand moveCommand;

        if (MoveCommand.CreateCommand(unit, pathToDest, out moveCommand))
        {
            unit.EnqueueCommand(moveCommand);

            // update paths in the destination cube
            (cubeClicked as Cube).UpdatePaths(
                unit.actionPoints / unit.GetActionSlot(ActionType.Move).cost,
                cube => (cube as Cube).GetUnit() != null && (cube as Cube).GetUnit() != unit);
        }
    }
Пример #9
0
 // AI Simulation에서만 사용할 함수입니다.
 public static void ForceCreateCommand(PFPath path, out MoveCommand moveCommand)
 {
     moveCommand = new MoveCommand(path);
 }
Пример #10
0
 private MoveCommand(PFPath path)
 {
     _path = path;
 }
Пример #11
0
 public int CalcMoveAPCost(PFPath path) => (path.path.Count - 1) * owner.GetActionSlot(ActionType.Move).cost;
Пример #12
0
    /// <summary>
    /// maxDistance로 갈수 있는 큐브들을 BFS로 찾아 OnServe콜백함수의 PFPath인자로 돌려줍니다.
    /// </summary>
    /// <param name="maxDistance">BFS로 찾을 최대 거리</param>
    /// <param name="OnServe">함수가 끝나면 호출할 함수를 전달하세요. 함수의 인자로 Path가 전달됩니다.</param>
    /// <param name="cubeIgnore">Path에 포함시키지 않을 Predicate</param>
    /// <returns></returns>
    private IEnumerator BFSPathfinding(
        INavable start, List <INavable> navables, int maxDistance,
        Action <List <PFPath> > OnServe, Func <INavable, bool> cubeIgnore)
    {
        OnSearchBegin();

        // 나중에 cost가 정해진 노드들만 path로 만들기 위함
        List <PFNode> table = new List <PFNode>();

        // BFS: Initialization
        Queue <PFNode> queue     = new Queue <PFNode>();
        PFNode         startNode = new PFNode(start, null, 0);

        queue.Enqueue(startNode);
        table.Add(startNode);

        // BFS: Traversal
        int maxLoop  = 40;
        int currLoop = 0;

        while (queue.Count > 0)
        {
            PFNode currNode = queue.Dequeue();
            if (currNode.cost >= maxDistance)
            {
                continue;
            }

            List <INavable> neighborCubes = currNode.cube.Neighbors;

            foreach (var neighborCube in neighborCubes)
            {
                if (cubeIgnore(neighborCube))
                {
                    continue;
                }
                if (table.Any(node => node.cube == neighborCube))
                {
                    continue;                                               // 이미 다른 Path에 있음
                }
                PFNode newNode = new PFNode(neighborCube, currNode, currNode.cost + 1);
                queue.Enqueue(newNode);
                table.Add(newNode);
            }
            currLoop++;

            if (currLoop >= maxLoop)
            {
                currLoop = 0;
                yield return(null);
            }
        }

        // Path Construction
        List <PFPath> paths = new List <PFPath>();

        currLoop = 0;
        foreach (var destination in table)
        {
            PFPath path = new PFPath(start, destination);
            path.Add(destination);

            PFNode currNode = destination;
            while (currNode.prevNode != null)
            {
                path.Add(currNode.prevNode);
                currNode = currNode.prevNode;
            }
            path.Reverse();

            paths.Add(path);

            currLoop++;
            if (currLoop >= maxLoop)
            {
                currLoop = 0;
                yield return(null);
            }
        }

        // return by Calling Callback Function
        OnServe(paths);
        OnSearchEnd();
    }
Пример #13
0
 public Unit_Move_(Unit owner, PFPath path, int apCost) : base(owner)
 {
     _path      = path;
     _cost      = apCost;
     _cubesToGo = new Queue <Cube>(path.path.Cast <Cube>());
 }