예제 #1
0
        public static AggregateUpdateResult PerformActionSequence(Level level, PlayerActions[] actionSequence, int maxTicks = 100)
        {
            if (actionSequence.Length < 1)
            {
                throw new ArgumentOutOfRangeException("Must have at least one action to perform");
            }

            AggregateUpdateResult result = new AggregateUpdateResult();
            int ticks = 0;

            for (int i = 0; i < actionSequence.Length; i++)
            {
                result = level.DoPlayerAction(actionSequence[i]);
                ++ticks;
                while (result.Result == AggregateUpdateResult.ResultTypes.RequiresUpdate)
                {
                    if (++ticks > maxTicks)
                    {
                        throw new Exception($"Action [{actionSequence[i]}] sequence didn't finish updating within {maxTicks}");
                    }
                    result = level.UpdateLevel();
                }
            }
            return(result);
        }
예제 #2
0
            private static MoveResult GetNextMoveBranch(PlayerActions action, Level level)
            {
                var updateSnapshots = new HashSet <LevelSnapshot>();

                AggregateUpdateResult result = level.DoPlayerAction(action);

                while (result.Result == AggregateUpdateResult.ResultTypes.RequiresUpdate)
                {
                    result = level.UpdateLevel();
                    var currentSnapshot = level.InitializeSnapshot();
                    if (updateSnapshots.Any(s => s.TimeAgnosticEquals(currentSnapshot)))
                    {
                        return(null);                                                                                     // Infinite loop
                    }
                    updateSnapshots.Add(currentSnapshot);
                }

                LevelSnapshot levelSnapshot = level.InitializeSnapshot();

                return(new MoveResult()
                {
                    AggregateUpdateResult = result,
                    ResultSnapshot = levelSnapshot
                });
            }
예제 #3
0
        private void HandleUpdateResult(AggregateUpdateResult aggregateUpdateResult, PlayerActions causalAction = PlayerActions.None)
        {
            switch (aggregateUpdateResult.Result)
            {
            case AggregateUpdateResult.ResultTypes.Cancelled:
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    dynamicSpriteObject.CancelAction(causalAction);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    staticSpriteObject.CancelAction(causalAction);
                }
                _updateFinished = true;
                break;

            case AggregateUpdateResult.ResultTypes.RequiresUpdate:
                _updateFinished = false;
                // TODO: Find a way to cache the following update loops?
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    var updateResult = aggregateUpdateResult.EntityUpdateResults[dynamicSpriteObject.ID];
                    dynamicSpriteObject.UpdateToResult(updateResult);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    if (aggregateUpdateResult.EntityUpdateResults.ContainsKey(staticSpriteObject.ID))
                    {
                        var updateResult = aggregateUpdateResult.EntityUpdateResults[staticSpriteObject.ID];
                        staticSpriteObject.UpdateToResult(updateResult);
                    }
                }

                RegisterLevelStabilizedCallback(() =>
                {
                    InvokeEndOfUpdateCallbacks();
                    UpdateLevel();
                });
                break;

            case AggregateUpdateResult.ResultTypes.DoneUpdating:
                _updateFinished = false;
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    var updateResult = aggregateUpdateResult.EntityUpdateResults[dynamicSpriteObject.ID];
                    dynamicSpriteObject.UpdateToResult(updateResult);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    if (aggregateUpdateResult.EntityUpdateResults.ContainsKey(staticSpriteObject.ID))
                    {
                        var updateResult = aggregateUpdateResult.EntityUpdateResults[staticSpriteObject.ID];
                        staticSpriteObject.UpdateToResult(updateResult);
                    }
                }

                RegisterLevelStabilizedCallback(() =>
                {
                    InvokeEndOfUpdateCallbacks();
                    _updateFinished = true;
                });
                break;

            case AggregateUpdateResult.ResultTypes.LevelComplete:
                _updateFinished = false;
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    var updateResult = aggregateUpdateResult.EntityUpdateResults[dynamicSpriteObject.ID];
                    dynamicSpriteObject.UpdateToResult(updateResult);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    if (aggregateUpdateResult.EntityUpdateResults.ContainsKey(staticSpriteObject.ID))
                    {
                        var updateResult = aggregateUpdateResult.EntityUpdateResults[staticSpriteObject.ID];
                        staticSpriteObject.UpdateToResult(updateResult);
                    }
                }

                RegisterLevelStabilizedCallback(() =>
                {
                    AnalyticsHelper.SendLevelCompleteAnalyticsEventAsync(_currentLevel);

                    LevelManager.SolveLevel(_currentLevelPack, _currentLevel.Info.ID, _currentLevel.IsWithinTargetMoves, _currentLevel.HasCollectedAllSushi);
                    _updateFinished = true;
                    UIManager.SetLevelCompleteStars(_currentLevel.HasCollectedAllSushi, _currentLevel.IsWithinTargetMoves);
                    UIManager.PlayLevelCompleteAnimation();
                });
                break;

            case AggregateUpdateResult.ResultTypes.UndoPerformed:
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    var updateResult = aggregateUpdateResult.EntityUpdateResults[dynamicSpriteObject.ID];
                    dynamicSpriteObject.UndoToResult(updateResult);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    if (aggregateUpdateResult.EntityUpdateResults.ContainsKey(staticSpriteObject.ID))
                    {
                        var updateResult = aggregateUpdateResult.EntityUpdateResults[staticSpriteObject.ID];
                        staticSpriteObject.UndoToResult(updateResult);
                    }
                }

                _updateFinished = true;
                break;

            case AggregateUpdateResult.ResultTypes.FatalResult:
                _updateFinished = false;
                foreach (var dynamicSpriteObject in _dynamicSpriteObjects)
                {
                    var updateResult = aggregateUpdateResult.EntityUpdateResults[dynamicSpriteObject.ID];
                    dynamicSpriteObject.UpdateToResult(updateResult);
                }
                foreach (var staticSpriteObject in _staticSpriteObjects)
                {
                    if (aggregateUpdateResult.EntityUpdateResults.ContainsKey(staticSpriteObject.ID))
                    {
                        var updateResult = aggregateUpdateResult.EntityUpdateResults[staticSpriteObject.ID];
                        staticSpriteObject.UpdateToResult(updateResult);
                    }
                }

                RegisterLevelStabilizedCallback(() =>
                {
                    _updateFinished = true;
                    Undo();
                });
                break;

            default:
                Debug.LogError($"Unimplemented AggregateUpdateResult {aggregateUpdateResult.Result}");
                break;
            }
        }