// This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Add framework services.
            services.AddMvc()
            .AddApplicationPart(Assembly.Load(new AssemblyName(typeof(ProgressController).Namespace)));     // because TestServer bug when controller in other project

            // Dependency Injection
            var assemblyName = typeof(JsonQuestRepository).Namespace;
            var assembly     = Assembly.Load(new AssemblyName(assemblyName));
            var resourceName = $"{assemblyName}.QuestConfiguration.json";
            QuestConfiguration questConfiguration = null;

            using (Stream stream = assembly.GetManifestResourceStream(resourceName))
                using (var reader = new StreamReader(stream))
                {
                    string questConfigurationJson = reader.ReadToEnd();
                    questConfiguration = JsonConvert.DeserializeObject <QuestConfiguration>(questConfigurationJson);
                }
            services.AddSingleton <IQuestRepository>(new JsonQuestRepository(questConfiguration));

            // Add framework services.
            services.AddDbContext <ScoringDbContext>(options =>
                                                     options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddTransient <IPlayerScoringRepository, EfMsSqlPlayerScoringRepository>();
        }
        public async Task <IActionResult> GetProgressAsync([FromBody] ProgressQueryViewModel progressQuery)
        {
            // defensive code
            GuardClause(ModelState, progressQuery);
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            // get the quest configuration
            QuestConfiguration questConfiguration = await _questRepository.GetQuestAsync();

            // get current score
            PlayerScoring playerScoring = await _playerScoringRepository.GetPlayerScoringAsync(progressQuery.PlayerId);

            decimal totalQuestPointAccumulated = playerScoring.Score
                                                 + (progressQuery.ChipAmountBet * questConfiguration.RateFromBet)
                                                 + (progressQuery.PlayerLevel * questConfiguration.LevelBonusRate);

            // new milestones reached?
            IEnumerable <Milestone> newCompletedMilestones = questConfiguration.Milestones
                                                             .Where(m =>
                                                                    !playerScoring.CompletedMilestoneIndices.Contains(m.MilestoneIndex) && // non completed yet
                                                                    m.PointsNeededToComplete <= totalQuestPointAccumulated // new milestone achieved
                                                                    );

            // upsert the user's score and new completed milestones player score
            await _playerScoringRepository.UpsertPlayerScoringAsync(
                progressQuery.PlayerId,
                totalQuestPointAccumulated,
                newCompletedMilestones?.Select(m => m.MilestoneIndex) ?? Enumerable.Empty <int>());

            return(Ok(new ProgressViewModel
            {
                QuestPointsEarned = totalQuestPointAccumulated,
                TotalQuestPercentCompleted = totalQuestPointAccumulated / questConfiguration.TotalPointNeededToComplete * 100,
                MilestonesCompleted = questConfiguration.Milestones
                                      .Where(m => playerScoring.CompletedMilestoneIndices.Contains(m.MilestoneIndex)) // already completed milestones
                                      .Concat(newCompletedMilestones)
                                      .Select(m =>
                                              new MilestoneViewModel
                {
                    MilestoneIndex = m.MilestoneIndex,
                    ChipsAwarded = m.ChipAwarded
                })
            }));
        }
        PlayerProgress CalculateProgress(QuestConfiguration configuration, Player player, PlayerBet bet)
        {
            var totalPointNeeded = configuration.Quest.QuestPointNeeded;
            var questPointEarned = bet.ChipAmountBet * configuration.RateFromBet + bet.PlayerLevel * configuration.LevelBonusRate;

            var questMilestones     = configuration.Milestones.OrderBy(x => x.Index);
            var milestonesCompleted = new List <MilestoneCompleted>();

            var lastMilestoneIndex = 0;
            var totalQuestPoint    = questPointEarned;
            var percentCompleted   = questPointEarned / totalPointNeeded * 100;

            if (player.QuestId == configuration.Quest.Id)
            {
                totalQuestPoint    = questPointEarned + player.QuestPoint;
                lastMilestoneIndex = player.MilestoneIndex;
                percentCompleted   = (questPointEarned + player.QuestPoint) / totalPointNeeded * 100;
            }

            var projectedMilestoneIndex = questMilestones.Last(x => x.TotalQuestPoint <= totalQuestPoint).Index;

            foreach (Milestone milestone in questMilestones)
            {
                if (milestone.Index > lastMilestoneIndex && milestone.Index <= projectedMilestoneIndex)
                {
                    milestonesCompleted.Add(new MilestoneCompleted
                    {
                        MilestoneIndex = milestone.Index,
                        ChipsAwarded   = milestone.ChipsAwarded
                    });
                }
            }

            var result = new PlayerProgress
            {
                QuestPointsEarned          = questPointEarned,
                TotalQuestPercentCompleted = percentCompleted > 100 ? 100 : percentCompleted,
                MilestonesCompleted        = milestonesCompleted
            };

            return(result);
        }
Beispiel #4
0
 public StateController(IPlayerRepository playerRepository, IOptions <QuestConfiguration> configuration)
 {
     _playerRepository = playerRepository;
     _configuration    = configuration.Value;
 }
 public JsonQuestRepository(QuestConfiguration questConfiguration)
 {
     _questConfiguration = questConfiguration;
 }