Пример #1
0
        void ITick.Tick(Actor self)
        {
            if (IsTraitDisabled || IsTraitPaused)
            {
                return;
            }

            if (self.CurrentActivity == null)
            {
                return;
            }

            var targets = self.CurrentActivity.GetTargets(self);

            if (!targets.Any())
            {
                return;
            }

            var positions = targets.First().Positions;

            if (!positions.Any())
            {
                return;
            }

            var moveDuration = move.EstimatedMoveDuration(self, self.CenterPosition, positions.First());

            if (moveDuration < info.EmergeDuration)
            {
                return;
            }

            if (facing.Facing == Left)
            {
                var left = NormalizeSequence(self, info.LeftSequence);
                if (DefaultAnimation.CurrentSequence.Name != left)
                {
                    DefaultAnimation.PlayThen(left, () => CancelCustomAnimation(self));
                }
            }
            else if (facing.Facing == Right)
            {
                var right = NormalizeSequence(self, info.RightSequence);
                if (DefaultAnimation.CurrentSequence.Name != right)
                {
                    DefaultAnimation.PlayBackwardsThen(right, () => CancelCustomAnimation(self));
                }
            }
        }
Пример #2
0
        /// <summary>
        /// Called by CaptureActor when the activity is ready to enter and capture the target.
        /// This method grants the capturing conditions on the captor and target and returns
        /// true if the captor is able to start entering or false if it needs to wait.
        /// </summary>
        public bool StartCapture(Actor self, Actor target, CaptureManager targetManager, out Captures captures)
        {
            captures = null;

            // Prevent a capture being restarted after it has been canceled during disposal
            if (self.WillDispose)
            {
                return(false);
            }

            if (target != currentTarget)
            {
                if (currentTarget != null)
                {
                    CancelCapture(self, currentTarget, currentTargetManager);
                }

                targetManager.currentCaptors.Add(self);
                currentTarget        = target;
                currentTargetManager = targetManager;
                currentTargetDelay   = 0;
            }
            else
            {
                currentTargetDelay += 1;
            }

            if (capturingToken == Actor.InvalidConditionToken)
            {
                capturingToken = self.GrantCondition(info.CapturingCondition);
            }

            if (targetManager.beingCapturedToken == Actor.InvalidConditionToken)
            {
                targetManager.beingCapturedToken = target.GrantCondition(targetManager.info.BeingCapturedCondition);
            }

            captures = enabledCaptures
                       .OrderBy(c => c.Info.CaptureDelay)
                       .FirstOrDefault(c => targetManager.CanBeTargetedBy(target, self, c));

            if (captures == null)
            {
                return(false);
            }

            // HACK: Make sure the target is not moving and at its normal position with respect to the cell grid
            var enterMobile = target.TraitOrDefault <Mobile>();

            if (enterMobile != null && enterMobile.IsMovingBetweenCells)
            {
                return(false);
            }

            if (progressWatchers.Any() || targetManager.progressWatchers.Any())
            {
                currentTargetTotal = captures.Info.CaptureDelay;
                if (move != null && captures.Info.ConsumedByCapture)
                {
                    var pos = target.GetTargetablePositions().PositionClosestTo(self.CenterPosition);
                    currentTargetTotal += move.EstimatedMoveDuration(self, self.CenterPosition, pos);
                }

                foreach (var w in progressWatchers)
                {
                    w.Update(self, self, target, currentTargetDelay, currentTargetTotal);
                }

                foreach (var w in targetManager.progressWatchers)
                {
                    w.Update(target, self, target, currentTargetDelay, currentTargetTotal);
                }
            }

            enteringCurrentTarget = currentTargetDelay >= captures.Info.CaptureDelay;
            return(enteringCurrentTarget);
        }
        /// <summary>
        /// Called by CaptureActor when the activity is ready to enter and capture the target.
        /// This method grants the capturing conditions on the captor and target and returns
        /// true if the captor is able to start entering or false if it needs to wait.
        /// </summary>
        public bool StartCapture(Actor self, Actor target, CaptureManager targetManager, out Captures captures)
        {
            captures = null;

            // Prevent a capture being restarted after it has been canceled during disposal
            if (self.WillDispose)
            {
                return(false);
            }

            if (target != currentTarget)
            {
                if (currentTarget != null)
                {
                    CancelCapture(self, currentTarget, currentTargetManager);
                }

                targetManager.currentCaptors.Add(self);
                currentTarget        = target;
                currentTargetManager = targetManager;
                currentTargetDelay   = 0;
            }
            else
            {
                currentTargetDelay += 1;
            }

            if (conditionManager != null && !string.IsNullOrEmpty(info.CapturingCondition) &&
                capturingToken == ConditionManager.InvalidConditionToken)
            {
                capturingToken = conditionManager.GrantCondition(self, info.CapturingCondition);
            }

            if (targetManager.conditionManager != null && !string.IsNullOrEmpty(targetManager.info.BeingCapturedCondition) &&
                targetManager.beingCapturedToken == ConditionManager.InvalidConditionToken)
            {
                targetManager.beingCapturedToken = targetManager.conditionManager.GrantCondition(target, targetManager.info.BeingCapturedCondition);
            }

            captures = enabledCaptures
                       .OrderBy(c => c.Info.CaptureDelay)
                       .FirstOrDefault(c => targetManager.CanBeTargetedBy(target, self, c));

            if (captures == null)
            {
                return(false);
            }

            if (progressWatchers.Any() || targetManager.progressWatchers.Any())
            {
                currentTargetTotal = captures.Info.CaptureDelay;
                if (move != null && captures.Info.ConsumedByCapture)
                {
                    var pos = target.GetTargetablePositions().PositionClosestTo(self.CenterPosition);
                    currentTargetTotal += move.EstimatedMoveDuration(self, self.CenterPosition, pos);
                }

                foreach (var w in progressWatchers)
                {
                    w.Update(self, self, target, currentTargetDelay, currentTargetTotal);
                }

                foreach (var w in targetManager.progressWatchers)
                {
                    w.Update(target, self, target, currentTargetDelay, currentTargetTotal);
                }
            }

            enteringCurrentTarget = currentTargetDelay >= captures.Info.CaptureDelay;
            return(enteringCurrentTarget);
        }