Пример #1
0
        public bool Handle(DomainEventHandlerData <BattleEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles.FirstOrDefault(e => e.Id == @event.EventObject.AtCastleId);

            if (castle?.Siege?.Soldiers == null)
            {
                return(false);
            }
            var attacking = castle.Siege.Soldiers;
            var defending = castle.Soldiers.Where(e => !e.IsDead).ToList();
            // boost strength
            var hero = castle.Heroes?.FirstOrDefault(e => e.Army != castle.Army);
            var attackingBoostStrength = hero == null ? 0 : _repository.GetHeroById(hero.UserId, hero.Id.ToString())?.Leadership ?? 0;

            hero = castle.Heroes?.FirstOrDefault(e => e.Army == castle.Army);
            var defendingBoostStrength = hero == null ? 0 : _repository.GetHeroById(hero.UserId, hero.Id.ToString())?.Leadership ?? 0;

            var battle = _gameDomainService.AttackSequence(@event.EventObject.Id,
                                                           castle,
                                                           castle.Siege.OwnerUserId,
                                                           castle.OwnerUserId,
                                                           attacking,
                                                           defending,
                                                           attackingBooststrength: attackingBoostStrength,
                                                           defendingBooststrength: defendingBoostStrength);

            // attacking win
            if (attacking.Count(e => !e.IsDead && e.CastleTroopType.Health > 0) > 0)
            {
                // add event
                // for user
                _domain.AddEvent(snap.Id, new OccupiedCastleEvent(castle.Siege.OwnerUserId, castle.Id, battle, DateTime.UtcNow));
                // for old owner of castle
                if (!string.IsNullOrEmpty(castle.OwnerUserId))
                {
                    _domain.AddEvent(snap.Id, new CastleHasBeenOccupiedEvent(castle.OwnerUserId, castle.Id, battle, DateTime.UtcNow));
                }
            }
            else
            {
                // defending win
                castle.Soldiers = castle.Soldiers.Where(e => e.CastleTroopType.Health > 0 && !e.IsDead).ToList();
                castle.UpdateSoldierAmount();
                _gameDomainService.CreateSoldierIfNeed(snap);
                // for depending
                if (!string.IsNullOrEmpty(castle.OwnerUserId))
                {
                    _domain.AddEvent(snap.Id, new DefendedCastleEvent(castle.OwnerUserId, castle.Id, battle, DateTime.UtcNow));
                }
                // for attacking
                _domain.AddEvent(snap.Id, new FailedAttackCastleEvent(castle.Siege.OwnerUserId, castle.Id, battle, DateTime.UtcNow));
            }
            return(true);
        }
Пример #2
0
        private async Task AddSoldierForAcceptStep(Guid gameId)
        {
            var gameStream = await Build(gameId, string.Empty, -1);

            var userFirstSoldier = _gameDomainService.GetCreateSoldierEvent(gameId, Army.Blue, gameStream.UserProducedTroopTypes.First(),
                                                                            gameStream.UserId, true);
            var userCreateSoldier = _gameDomainService.GetCreateSoldierEvent(gameId, Army.Blue, gameStream.UserProducedTroopTypes.First(),
                                                                             gameStream.UserId);
            var opponentFirstSoldier = _gameDomainService.GetCreateSoldierEvent(gameId, Army.Red, gameStream.UserProducedTroopTypes.First(),
                                                                                gameStream.OpponentId, true);
            var opponentCreateSoldier = _gameDomainService.GetCreateSoldierEvent(gameId, Army.Red, gameStream.UserProducedTroopTypes.First(),
                                                                                 gameStream.OpponentId);

            _domain.AddEvent(gameId, userFirstSoldier, userCreateSoldier, opponentFirstSoldier, opponentCreateSoldier);
        }
Пример #3
0
        public void AddSiegeEvent(GameAggregate game, CastleAggregate destinationCastle, List <SoldierAggregate> soldiers)
        {
            if (destinationCastle.Siege == null)
            {
                return;
            }
            var battleAt = GetBattleTime(game.Speed);

            _domain.AddEvent(game.Id,
                             new SiegeCastleEvent(destinationCastle.Siege.OwnerUserId,
                                                  destinationCastle.Id,
                                                  soldiers,
                                                  DateTime.UtcNow,
                                                  battleAt));
        }
Пример #4
0
        public bool Handle(DomainEventHandlerData <StartBattalionEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles?.FirstOrDefault(e => e.Id == @event.EventObject.CastleId);

            if (castle == null)
            {
                return(false);
            }
            var movedSoldiers = castle.Soldiers.Where(s => @event.EventObject.Soldiers.Any(e => new Guid(e) == s.Id)).ToList();

            castle.Soldiers.RemoveAll(s => @event.EventObject.Soldiers.Any(e => new Guid(e) == s.Id));
            castle.UpdateSoldierAmount();
            var e2 = new BattalionMovementEvent(castle.Id,
                                                @event.EventObject.DestinationCastleId,
                                                movedSoldiers,
                                                @event.EventObject.Route,
                                                @event.EventObject.CreatedBy,
                                                DateTime.UtcNow, DateTime.UtcNow.Add(@event.EventObject.Route.Duration));

            e2.Id = @event.EventObject.MovementId;
            _domain.AddEvent(snap.Id, e2);
            _gameDomainService.CreateSoldierIfNeed(snap);
            return(true);
        }
        public bool Handle(DomainEventHandlerData <UpkeepCoinEvent> @event)
        {
            var snap = @event.Snapshot as GameAggregate;

            if (snap == null)
            {
                return(false);
            }
            var relateEvents = new List <EventBase>();
            var userCastles  = snap.Castles.Where(e => e.OwnerUserId == snap.UserId).ToList() ?? new List <CastleAggregate>();

            foreach (var castle in userCastles)
            {
                var coins = _gameDomainService.CalculateUpkeepCoin(snap.Id, castle);
                snap.UserCoins -= coins;
                relateEvents.Add(new CastleUpkeepCointEvent(castle.Id, coins, snap.UserId, DateTime.UtcNow, DateTime.UtcNow));
                //var createSoldier = _gameDomainService.GetCreateSoldierIfNeedCreate(snap, castle);
                //if (createSoldier != null)
                //    relateEvents.Add(createSoldier);
                //var isCreated = _gameDomainService.CreateSoldierIfNeed(snap, castle);
                //if (!isCreated && castle.Army != Army.Neutrual && (castle.Army == Army.Blue || !snap.SelfPlaying))
                //{
                //    var troopType = castle.GetDefaultTroopType();
                //    var needCoin = _gameDomainService.GetUpkeepCoinBySoldierType(castle, troopType);
                //    coins = castle.Army == Army.Blue ? snap.UserCoins : snap.OpponentCoins;
                //    if (needCoin > coins && castle.IsProductionState())
                //    {
                //        relateEvents.Add(new SuspendCastleProductionEvent(castle.Id, castle.OwnerUserId));
                //    }
                //}
            }

            var opponentCastles = snap.Castles.Where(e => e.OwnerUserId == snap.OpponentId).ToList() ?? new List <CastleAggregate>();

            foreach (var castle in opponentCastles)
            {
                var coins = _gameDomainService.CalculateUpkeepCoin(snap.Id, castle);
                snap.OpponentCoins -= coins;
                relateEvents.Add(new CastleUpkeepCointEvent(castle.Id, coins, snap.OpponentId, DateTime.UtcNow, DateTime.UtcNow));
                //var createSoldier = _gameDomainService.GetCreateSoldierIfNeedCreate(snap, castle);
                //if (createSoldier != null)
                //    relateEvents.Add(createSoldier);
                //var isCreated = _gameDomainService.CreateSoldierIfNeed(snap, castle);
                //if (!isCreated && castle.Army != Army.Neutrual && (castle.Army == Army.Blue || !snap.SelfPlaying))
                //{
                //    var troopType = castle.GetDefaultTroopType();
                //    var needCoin = _gameDomainService.GetUpkeepCoinBySoldierType(castle, troopType);
                //    coins = castle.Army == Army.Blue ? snap.UserCoins : snap.OpponentCoins;
                //    if (needCoin > coins && castle.IsProductionState())
                //    {
                //        relateEvents.Add(new SuspendCastleProductionEvent(castle.Id, castle.OwnerUserId));
                //    }
                //}
            }

            relateEvents.Add(_gameDomainService.UpkeepCoinEvent(snap.Speed));
            _domainService.AddEvent(snap.Id, relateEvents.ToArray());
            return(true);
        }
        public bool Handle(DomainEventHandlerData <SiegeCastleEvent> @event)
        {
            var snap = @event.Snapshot as GameAggregate;

            if (snap == null)
            {
                return(false);
            }
            _domain.AddEvent(snap.Id, new BattleEvent(@event.EventObject.CastleId, DateTime.UtcNow, DateTime.UtcNow));
            return(true);
        }
Пример #7
0
        public bool Handle(DomainEventHandlerData <UpgradeCastleEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles.FirstOrDefault(e => e.Id == @event.EventObject.CastleId);

            if (castle == null)
            {
                return(false);
            }
            castle.Strength++;
            var coins = _domainService.GetCoinsToUpgradeCastle(castle.Strength);

            _domain.AddEvent(snap.Id, new DeficitCoinsEvent(coins, castle.Army, castle.OwnerUserId));
            return(true);
        }
Пример #8
0
        public bool Handle(DomainEventHandlerData <OccupiedCastleEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles.FirstOrDefault(e => e.Id == @event.EventObject.CastleId);

            if (castle?.Siege == null)
            {
                return(false);
            }
            var liveSoldiers = castle.Siege.Soldiers?.Where(e => e.CastleTroopType.Health > 0).ToList() ?? new List <SoldierAggregate>();

            castle.Soldiers = liveSoldiers;
            castle.UpdateSoldierAmount();
            var army = snap.UserId == castle.Siege.OwnerUserId ? Army.Blue : Army.Red;

            castle.Siege = null;
            castle.Army  = army;
            if (army == Army.Blue)
            {
                castle.OwnerId     = snap.UserHeroId;
                castle.OwnerUserId = snap.UserId;
            }
            else
            {
                castle.OwnerId     = snap.OpponentHeroId;
                castle.OwnerUserId = snap.OpponentId;
            }
            // check end game status
            bool isBlueWin = snap.Castles.All(e => e.Army == Army.Blue);
            var  isRedWin  = snap.Castles.All(e => e.Army == Army.Red);

            if (isBlueWin || isRedWin)
            {
                _domain.AddEvent(snap.Id, new EndGameEvent(isBlueWin ? Army.Blue : Army.Red, DateTime.UtcNow));
                return(true);
            }
            _gameDomainService.CreateSoldierIfNeed(snap);
            return(true);
        }
        public bool Handle(DomainEventHandlerData <RevenueCointEvent> @event)
        {
            var snap = @event.Snapshot as GameAggregate;

            if (snap == null)
            {
                return(false);
            }
            var relateEvents = new List <EventBase>();
            var userCastles  = snap.Castles.Where(e => e.OwnerUserId == snap.UserId).ToList() ?? new List <CastleAggregate>();

            foreach (var castle in userCastles)
            {
                var coins = _gameDomainService.CalculateCoin(snap, castle);
                snap.UserCoins += coins;
                relateEvents.Add(new CastleRevenueCointEvent(castle.Id, coins, snap.UserId, DateTime.UtcNow, DateTime.UtcNow));
                //var createSoldier = _gameDomainService.GetCreateSoldierIfNeedCreate(snap, castle);
                //if (createSoldier != null)
                //    relateEvents.Add(createSoldier);
            }

            var opponentCastles = snap.Castles.Where(e => e.OwnerUserId == snap.OpponentId).ToList() ?? new List <CastleAggregate>();

            foreach (var castle in opponentCastles)
            {
                var coins = _gameDomainService.CalculateCoin(snap, castle);
                snap.OpponentCoins += coins;
                relateEvents.Add(new CastleRevenueCointEvent(castle.Id, coins, snap.OpponentId, DateTime.UtcNow, DateTime.UtcNow));
                //var createSoldier = _gameDomainService.GetCreateSoldierIfNeedCreate(snap, castle);
                //if (createSoldier != null)
                //    relateEvents.Add(createSoldier);
            }
            relateEvents.Add(_gameDomainService.RevenueCoinEvent(snap.Speed));
            _domainService.AddEvent(snap.Id, relateEvents.ToArray());
            return(true);
        }
        public bool Handle(DomainEventHandlerData <BattalionMovementEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles?.FirstOrDefault(e => e.Id == @event.EventObject.CastleId);

            if (castle == null)
            {
                return(false);
            }
            var destination = snap.Castles?.FirstOrDefault(e => e.Id == @event.EventObject.DestinationCastleId);

            if (destination == null)
            {
                return(false);
            }
            if (castle.Army == destination.Army)
            {
                // just add soldier
                if (destination.Soldiers == null)
                {
                    destination.Soldiers = new List <SoldierAggregate>();
                }
                var soldierCanAdd = destination.MaxResourceLimit - destination.Soldiers.Count;
                if (soldierCanAdd > 0)
                {
                    var canAddSoldiers = @event.EventObject.Soldiers
                                         .Where(e => destination.Soldiers.All(f => f.Id != e.Id))
                                         .OrderByDescending(e => e.CastleTroopType.Health)
                                         .Take(
                        soldierCanAdd);
                    destination.Soldiers.AddRange(canAddSoldiers);
                    destination.UpdateSoldierAmount();
                }
                if (@event.EventObject.Soldiers.Count > soldierCanAdd)
                {
                    //todo: fill all soldier still in battalion to closest castle
                }
                return(true);
            }
            // check siege of destination castle
            if (destination.Siege == null)
            {
                _gameDomainService.AddSiegeEvent(snap, castle, destination, @event.EventObject.Soldiers);
            }
            else if (destination.Siege.OwnerUserId != castle.OwnerUserId)
            {
                // start battle
                _domain.AddEvent(snap.Id,
                                 new BattleVersusSiegeEvent(
                                     castle.OwnerUserId,
                                     destination.Id,
                                     @event.EventObject.Soldiers,
                                     DateTime.UtcNow));
            }
            else
            {
                // add more soldier to siege
                if (destination.Siege.Soldiers == null)
                {
                    destination.Siege.Soldiers = new List <SoldierAggregate>();
                }
                var canAddSoldiers = @event.EventObject.Soldiers.Where(e => destination.Siege.Soldiers.All(f => f.Id != e.Id)).ToList();
                destination.Siege.Soldiers.AddRange(canAddSoldiers);
                castle.Soldiers.RemoveAll(e => canAddSoldiers.Any(f => f.Id == e.Id));
                destination.UpdateSoldierAmount();
                castle.UpdateSoldierAmount();
            }
            return(true);
        }
        public bool Handle(DomainEventHandlerData <BattleVersusSiegeEvent> @event)
        {
            var snap   = @event.Snapshot as GameAggregate;
            var castle = snap?.Castles.FirstOrDefault(e => e.Id == @event.EventObject.CastleId);

            if (castle?.Siege.Soldiers == null)
            {
                return(false);
            }
            var attacking = @event.EventObject.Battalion;
            var defending = castle.Siege.Soldiers;

            // boost strength
            var attackingArmy          = snap.UserId == @event.EventObject.AttackingUserId ? Army.Blue : Army.Red;
            var hero                   = castle.Heroes?.FirstOrDefault(e => e.Army == attackingArmy);
            var attackingBoostStrength = hero == null ? 0 : _repository.GetHeroById(hero.UserId, hero.Id.ToString())?.Leadership ?? 0;

            var defendingArmy = snap.UserId == castle.Siege.OwnerUserId ? Army.Blue : Army.Red;

            hero = castle.Heroes?.FirstOrDefault(e => e.Army == defendingArmy);
            var defendingBoostStrength = hero == null ? 0 : _repository.GetHeroById(hero.UserId, hero.Id.ToString())?.Leadership ?? 0;

            var battle = _gameDomainService.AttackSequence(@event.EventObject.Id,
                                                           castle,
                                                           @event.EventObject.AttackingUserId,
                                                           castle.Siege.OwnerUserId,
                                                           attacking,
                                                           defending,
                                                           attackingBoostStrength,
                                                           defendingBoostStrength);

            // attacking win
            if (attacking.Count(e => !e.IsDead && e.CastleTroopType.Health > 0) > 0)
            {
                var liveSoldiers = attacking.Where(e => e.CastleTroopType.Health > 0).ToList();
                // event for attacking
                _domain.AddEvent(snap.Id, new OccupiedSiegeInCastleEvent(
                                     @event.EventObject.AttackingUserId,
                                     castle.Id,
                                     battle,
                                     liveSoldiers, DateTime.UtcNow));
                // for old siege
                _domain.AddEvent(snap.Id, new SiegeHasBeenOccupiedEvent(castle.Siege.OwnerUserId,
                                                                        castle.Id,
                                                                        battle,
                                                                        DateTime.UtcNow));
            }
            else
            {
                // defending win
                // for defending
                _domain.AddEvent(snap.Id, new DefendedSiegeEvent(
                                     castle.Id, battle, castle.Siege.OwnerUserId));
                // for attacking
                _domain.AddEvent(snap.Id, new FailedAttackSiegeEvent(
                                     @event.EventObject.AttackingUserId,
                                     castle.Id,
                                     battle));
            }
            return(true);
        }