Beispiel #1
0
    // Update is called once per frame
    void Update()
    {
        base.Update();

        if (DrawTargetLine)
        {
            DrawLineTarget();
        }

        distance = Vector2.Distance(transform.position, TilePosition.ToWorldPoint());
        if (Vector2.Distance(transform.position, TilePosition.ToWorldPoint()) < ChangeDistance && CanChange)
        {
            ChooseDirectionMove();
        }
        if (distance > 0.4f)
        {
            CanChange = true;
        }

        else
        if (!VerifyDirection(GetDirectionVector(direction), 0.5f))
        {
            Direction newDirection = VerifyMinDistance(VerifyAvaliableDirections());
            CanChange = false;
            direction = newDirection;
            ChangeDirection(direction);
        }
    }
Beispiel #2
0
    // Update is called once per frame
    void Update()
    {
        base.Update();
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            VerifyChangeDirection(Direction.Up);
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            VerifyChangeDirection(Direction.Down);
        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            VerifyChangeDirection(Direction.Left);
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            VerifyChangeDirection(Direction.Right);
        }


        if (!VerifyDirection(GetDirectionVector(direction), 0.55f))
        {
            body.velocity = Vector2.zero;
            GetComponent <Animator>().speed = 0;
        }

        txt.text  = "Pac-man Position: " + TilePosition.x + "," + TilePosition.y;
        txt.text += "\nTile Position: " + TilePosition.ToWorldPoint().ToString();
    }
Beispiel #3
0
    public Vector2 PositionWithOffset(int offset)
    {
        switch (direction)
        {
        case Direction.Up:
            return(Vector2.up * offset + TilePosition.ToWorldPoint());

        case Direction.Down:
            return(Vector2.down * offset + TilePosition.ToWorldPoint());

        case Direction.Left:
            return(Vector2.left * offset + TilePosition.ToWorldPoint());

        case Direction.Right:
            return(Vector2.right * offset + TilePosition.ToWorldPoint());

        default:
            return(Vector2.zero);
        }
    }
Beispiel #4
0
 void ChangeDirection(Direction direction)
 {
     SetAnim();
     transform.position = TilePosition.ToWorldPoint();
     body.velocity      = GetDirectionVector(direction) * velocity;
 }
Beispiel #5
0
    Direction VerifyMinDistance(List <Direction> AvaliableDirections)
    {
        float        MinDistance     = 1000;
        float        dist            = 0;
        Direction    chooseDirection = direction;
        TilePosition newTile;

        foreach (Direction testDirection in AvaliableDirections)
        {
            switch (testDirection)
            {
            case Direction.Right:
                newTile    = new TilePosition();
                newTile.x  = TilePosition.x;
                newTile.y  = TilePosition.y;
                newTile.x += 1;
                Debug.DrawLine(Target, newTile.ToWorldPoint(), LineColor);
                dist = Vector2.Distance(Target, newTile.ToWorldPoint());
                if (dist < MinDistance)
                {
                    MinDistance     = dist;
                    chooseDirection = Direction.Right;
                }
                break;

            case Direction.Left:
                newTile    = new TilePosition();
                newTile.x  = TilePosition.x;
                newTile.y  = TilePosition.y;
                newTile.x -= 1;
                Debug.DrawLine(Target, newTile.ToWorldPoint(), LineColor);
                dist = Vector2.Distance(Target, newTile.ToWorldPoint());
                if (dist < MinDistance)
                {
                    MinDistance     = dist;
                    chooseDirection = Direction.Left;
                }
                break;

            case Direction.Up:
                newTile    = new TilePosition();
                newTile.x  = TilePosition.x;
                newTile.y  = TilePosition.y;
                newTile.y += 1;
                Debug.DrawLine(Target, newTile.ToWorldPoint(), LineColor);
                dist = Vector2.Distance(Target, newTile.ToWorldPoint());
                if (dist < MinDistance)
                {
                    MinDistance     = dist;
                    chooseDirection = Direction.Up;
                }
                break;

            case Direction.Down:
                newTile    = new TilePosition();
                newTile.x  = TilePosition.x;
                newTile.y  = TilePosition.y;
                newTile.y -= 1;
                Debug.DrawLine(Target, newTile.ToWorldPoint(), LineColor);
                dist = Vector2.Distance(Target, newTile.ToWorldPoint());
                if (dist < MinDistance)
                {
                    MinDistance     = dist;
                    chooseDirection = Direction.Down;
                }
                break;
            }
        }
        return(chooseDirection);
    }