예제 #1
0
        /// <inheritdoc/>
        public void ObjectMoved(ILocateable movedObject, MoveType moveType)
        {
            Point  targetPoint = movedObject.Position;
            object steps       = null;
            int    walkDelay   = 0;

            if (movedObject is ISupportWalk walker && moveType == MoveType.Walk)
            {
                targetPoint = walker.WalkTarget;
                walkDelay   = (int)walker.StepDelay.TotalMilliseconds;
                Span <WalkingStep> walkingSteps = new WalkingStep[16];
                var stepCount = walker.GetSteps(walkingSteps);
                var walkSteps = walkingSteps.Slice(0, stepCount).ToArray().Select(step => new { x = step.To.X, y = step.To.Y, direction = step.Direction }).ToList();

                var lastStep = walkSteps.LastOrDefault();
                if (lastStep != null)
                {
                    var lastPoint     = new Point(lastStep.x, lastStep.y);
                    var lastDirection = lastPoint.GetDirectionTo(targetPoint);
                    if (lastDirection != Direction.Undefined)
                    {
                        walkSteps.Add(new { x = targetPoint.X, y = targetPoint.Y, direction = lastDirection });
                    }
                }

                steps = walkSteps;
            }

            this.clientProxy.SendAsync("ObjectMoved", movedObject.Id, targetPoint.X, targetPoint.Y, moveType, walkDelay, steps);
        }
예제 #2
0
        private Span <WalkingStep> GetSteps(Point start, Span <Direction> directions)
        {
            var   result         = new WalkingStep[directions.Length];
            Point previousTarget = start;
            int   i = 0;

            foreach (var direction in directions)
            {
                var currentTarget = previousTarget.CalculateTargetPoint(direction);
                result[i] = new WalkingStep {
                    Direction = direction, To = currentTarget, From = previousTarget
                };
                i++;
                previousTarget = currentTarget;
            }

            return(result);
        }
예제 #3
0
        public void TestWalkStepsAreCorrect()
        {
            var player = this.DoTheWalk();

            // the next check is questionable - there is a timer which is removing a direction every 500ms. If the test runs "too slow", the count is 3 ;-)
            Span <WalkingStep> steps = new WalkingStep[16];
            var count = player.GetSteps(steps);

            Assert.That(count, Is.EqualTo(4));

            steps = steps.Slice(0, count);
            Assert.That(steps[0].From, Is.EqualTo(StartPoint));
            Assert.That(steps[steps.Length - 1].To, Is.EqualTo(EndPoint));
            foreach (var direction in steps)
            {
                Assert.That(direction.From, Is.Not.EqualTo(direction.To));
            }
        }
예제 #4
0
    IEnumerator WalkToStep(WalkingStep ws)
    {
        var     startPosition            = transform.localPosition;
        Vector2 destinationWorldPosition = MapLayout.ScreenPointFromMapPoint(ws.step.MapPoint);
        Vector2 fromWorldPosition        = MapLayout.ScreenPointFromMapPoint(ws.fromPoint);

        Tile fromTile, toTile;

        fromTile = controller.map.TileAtMapPoint(ws.fromPoint);
        toTile   = controller.map.TileAtMapPoint(currentPosition);

        float timer = 0.0f;

        Vector2 edge    = fromTile.edgeForDirection(ws.direction);
        float   divisor = 1.0f;

        if (edge.x != -1 && edge.y != -1)
        {
            var edgeDestination = new Vector3(fromWorldPosition.x + ((edge.x - 50.0f) / 100.0f), fromWorldPosition.y + (edge.y / 100.0f), 0);
            while (transform.localPosition != edgeDestination)
            {
                transform.localPosition = Vector3.MoveTowards(startPosition, edgeDestination, walkingSpeed * timer);
                timer += Time.fixedDeltaTime;

                yield return(new WaitForEndOfFrame());
            }

            divisor       = 2.0f;
            startPosition = edgeDestination;
        }

        var destination = new Vector3(destinationWorldPosition.x, destinationWorldPosition.y + (toTile.centreY / 100.0f));

        timer = 0.0f;

        while (transform.localPosition != destination)
        {
            transform.localPosition = Vector3.MoveTowards(startPosition, destination, walkingSpeed * timer);
            timer += Time.fixedDeltaTime;

            yield return(new WaitForEndOfFrame());
        }
    }
예제 #5
0
    IEnumerator WalkAlongPath()
    {
        // currentPath could be replaced underneath us if the user
        // changes destination mid-walk.

        StopCoroutine("WalkToStep");
        while (currentPath.Count > 0)
        {
            MovementStep step = currentPath[0];
            currentPath.RemoveAt(0);

            animator.SetBool("Walking", true);

            Map.Direction newDirection = Map.CalculateDirectionTravelling(currentPosition, step.MapPoint);
            animator.SetInteger("Direction", (int)newDirection);

            MapPoint fromPoint = currentPosition;
            currentPosition = step.MapPoint;

            WalkingStep ws = new WalkingStep {
                fromPoint = fromPoint,
                step      = step,
                direction = newDirection
            };

            yield return(StartCoroutine("WalkToStep", ws));
        }

        animator.SetBool("Walking", false);
        walking = false;

        if (currentCompletionHandler != null)
        {
            currentCompletionHandler(true);
        }
    }