Ejemplo n.º 1
0
        public async Task <BattleDto> CreateBattle(int initiatorId, int opponentId)
        {
            var initiator = await _heroService.FindById(initiatorId);

            var opponent = await _heroService.FindById(opponentId);

            var diff = DateTime.Now.Subtract(initiator.LastTimeMoved);

            if (diff.TotalMinutes < _appSettings.MinutesToWait)
            {
                var remainingSeconds = 300 - Math.Floor(diff.TotalSeconds);
                throw new InvalidTravel($"You still need to wait {remainingSeconds} seconds");
            }

            Battle newBattle = new Battle
            {
                InitiatorId = initiatorId,
                Latitude    = opponent.Latitude,
                Longitude   = opponent.Longitude
            };



            _context.Heroes.Update(initiator);
            await _context.SaveChangesAsync();

            var participants = await _heroService.GetHeroesInRange(opponentId);

            var heroInitiator = participants.FirstOrDefault(participant => participant.Id == initiatorId);

            if (heroInitiator == null)
            {
                participants.Add(initiator);
            }

            newBattle.Heroes = CreateHeroBattles(participants, newBattle);

            await _context.AddAsync(newBattle);

            await _context.SaveChangesAsync();

            BattleDto battleDto = new BattleDto
            {
                Id          = newBattle.Id,
                InitiatorId = newBattle.InitiatorId,
                OpponentId  = opponentId,
                Latitude    = newBattle.Latitude,
                Longitude   = newBattle.Longitude
            };

            var participantsList = participants.ToList();

            participantsList.ForEach(participant => participant.Badges  = null);
            participantsList.ForEach(participant => participant.Battles = null);

            battleDto.Heroes   = GetHeroesOfBattle(newBattle);
            battleDto.Villains = GetVillainsOfBattle(newBattle);

            battleDto.HeroesStrength   = battleDto.Heroes.Sum(v => v.OverallStrength);
            battleDto.VillainsStrength = battleDto.Villains.Sum(v => v.OverallStrength);

            return(battleDto);
        }
Ejemplo n.º 2
0
        public async Task <BattleResultDto> PlayGame(BattleDto battleDto)
        {
            Task.Delay(3000).Wait();

            var heroes = _context.Heroes
                         .Include(h => h.Powers).ThenInclude(hp => hp.Power)
                         .Include(h => h.Type)
                         .Include(h => h.Badges).ThenInclude(hp => hp.Badge);

            var initiator = await _heroService.FindById(battleDto.InitiatorId);

            var opponent = await _heroService.FindById(battleDto.OpponentId);

            initiator.Latitude      = opponent.Latitude + 0.1;
            initiator.Longitude     = opponent.Longitude + 0.1;
            initiator.LastTimeMoved = DateTime.Now;

            await _rewardService.AddBadge(BadgeType.TierCategory2, initiator);

            battleDto.Heroes           = _heroService.ModifyStrengthOfHeroParty(battleDto.Heroes.ToList());
            battleDto.Villains         = _villainService.ModifyStrengthOfHeroParty(battleDto.Villains.ToList());
            battleDto.HeroesStrength   = battleDto.Heroes.Sum(v => v.OverallStrength);
            battleDto.VillainsStrength = battleDto.Villains.Sum(v => v.OverallStrength);

            if (battleDto.VillainsStrength > battleDto.HeroesStrength)
            {
                foreach (var villain in battleDto.Villains)
                {
                    await SetWinner(villain.Id, battleDto.Id);

                    var dbHero = heroes.Where(h => h.IsBadGuy).FirstOrDefault(h => h.Id == villain.Id);
                    await _rewardService.AddBadge(BadgeType.TierCategory1, dbHero);
                }

                foreach (var hero in battleDto.Heroes)
                {
                    var dbHero = heroes.Where(h => !h.IsBadGuy).FirstOrDefault(h => h.Id == hero.Id);
                    var mostValuableBadgeType = _rewardService.GetMostValuableBadgeType(dbHero);
                    await _rewardService.DeleteBadge(mostValuableBadgeType, dbHero);
                }

                return(new BattleResultDto
                {
                    Result = Constants.VILLAINS_WON_MESSAGE,
                    HeroesStrength = battleDto.HeroesStrength,
                    VillainStrength = battleDto.VillainsStrength
                });
            }
            else if (battleDto.HeroesStrength == battleDto.VillainsStrength)
            {
                return(new BattleResultDto
                {
                    Result = Constants.EQUAL_SCORE_MESSAGE,
                    HeroesStrength = battleDto.HeroesStrength,
                    VillainStrength = battleDto.VillainsStrength
                });
            }
            else
            {
                foreach (var hero in battleDto.Heroes)
                {
                    await SetWinner(hero.Id, battleDto.Id);

                    var dbHero = heroes.Where(h => !h.IsBadGuy).FirstOrDefault(h => h.Id == hero.Id);
                    await _rewardService.AddBadge(BadgeType.TierCategory1, dbHero);
                }

                foreach (var villain in battleDto.Villains)
                {
                    var dbHero = heroes.Where(h => h.IsBadGuy).FirstOrDefault(h => h.Id == villain.Id);
                    var mostValuableBadgeType = _rewardService.GetMostValuableBadgeType(dbHero);
                    await _rewardService.DeleteBadge(mostValuableBadgeType, dbHero);
                }

                return(new BattleResultDto
                {
                    Result = Constants.HEROES_WON_MESSAGE,
                    HeroesStrength = battleDto.HeroesStrength,
                    VillainStrength = battleDto.VillainsStrength
                });
            }
        }
Ejemplo n.º 3
0
 public async Task <IActionResult> PlayGame([FromBody] BattleDto battleDto)
 {
     return(Ok(await _battleService.PlayGame(battleDto)));
 }