예제 #1
0
 public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     this.AfterTurnCountEvent.CardTargets  = cardTargets;
     this.AfterTurnCountEvent.EnemyTargets = targets;
     gameWorldManager.GameTurnManager.AfterTurnCountEvents.Add(this.AfterTurnCountEvent);
     return(true);
 }
예제 #2
0
        public bool CanUse(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            var canBeUsed = CanUseOverridable(gameWorldManager, targets, cardTargets);

            Logger.Log($"Checking if card can be used: {canBeUsed}");
            return(canBeUsed);
        }
예제 #3
0
        public virtual int CalculateDamageOverridable(IGameWorldManager gameWorldManager, int baseDamage, IEnemyInstance target)
        {
            //TODO: actually calculate shit here
            var calculatedValue = baseDamage;

            return(calculatedValue);
        }
예제 #4
0
        public int CalculateCost(IGameWorldManager gameWorldManager, int baseDamage, ICardInstance cardInstance)
        {
            //TODO: actually calculate shit here
            var calculatedValue = CalculateCostOverridable(gameWorldManager, cardInstance);

            Logger.Log($"Calculating actual cost: {calculatedValue} for card: {cardInstance.Name}({cardInstance.UniqueId})");
            return(calculatedValue);
        }
예제 #5
0
 public bool ActivateEffects(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     foreach (var cardEffect in CardEffects)
     {
         gameWorldManager.CardEffectManager.ActivateEffect(cardEffect.Key, cardEffect.Value, targets, cardTargets, this);
     }
     return(true);
 }
예제 #6
0
        public int CalculateDamage(IGameWorldManager gameWorldManager, int baseDamage, IEnemyInstance target)
        {
            //TODO: actually calculate shit here
            var calculatedValue = CalculateDamageOverridable(gameWorldManager, baseDamage, target);

            Logger.Log($"Calculating actual damage: {calculatedValue} for target: {target.Name}({target.UniqueId})");
            return(calculatedValue);
        }
예제 #7
0
 public CardInstance(BaseCard baseCard, IGameWorldManager gameWorldManager)
 {
     UniqueId         = Guid.NewGuid();
     BaseCard         = baseCard;
     GameWorldManager = gameWorldManager;
     ActualCost       = CalculateActualCost();
     CardUseType      = BaseCard.CardUseType;
 }
예제 #8
0
        public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            foreach (var cardInstance in cardTargets)
            {
                gameWorldManager.CardManager.MoveCardBetweenPiles(cardInstance, CardMovePoint.Hand, CardMovePoint.Deck);
            }

            return(true);
        }
예제 #9
0
        public override bool ActionWhenTriggered(IGameWorldManager gameWorldManager)
        {
            gameWorldManager.CardEffectManager.DamageTarget(new Null(), new DamageMultipleTimesEffect()
            {
                HitTimes = gameWorldManager.HeroManager.MetaInformation[MetaInformation.TimesPlayerGotDamagedThisTurn], DamageAmount = 1
            }, gameWorldManager.EnemyManager.Enemies);

            return(true);
        }
예제 #10
0
 public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     foreach (var cardTarget in cardTargets)
     {
         CardInstance newCard = new CardInstance(cardTarget.BaseCard, gameWorldManager);
         gameWorldManager.CardManager.Hand.Add(newCard);
     }
     return(true);
 }
예제 #11
0
        public override bool ActionWhenTriggered(IGameWorldManager gameWorldManager)
        {
            gameWorldManager.CardEffectManager.LoseHealth(1);
            gameWorldManager.CardEffectManager.DamageTarget(new Null(), new DamageMultipleTimesEffect()
            {
                HitTimes = 1, DamageAmount = 5
            }, gameWorldManager.EnemyManager.Enemies);

            return(true);
        }
예제 #12
0
        public override int CalculateDamageOverridable(IGameWorldManager gameWorldManager, int baseDamage, IEnemyInstance target)
        {
            int cardCountWithStrike = 0;

            cardCountWithStrike += gameWorldManager.CardManager.DeckPile.Count(x => x.Name.ToLower().Contains("strike"));
            cardCountWithStrike += gameWorldManager.CardManager.ExhaustPile.Count(x => x.Name.ToLower().Contains("strike"));
            cardCountWithStrike += gameWorldManager.CardManager.Hand.Count(x => x.Name.ToLower().Contains("strike"));
            cardCountWithStrike += gameWorldManager.CardManager.DiscardPile.Count(x => x.Name.ToLower().Contains("strike"));
            return(baseDamage + (cardCountWithStrike * 2));
        }
예제 #13
0
        public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            CardColor     targetCardColor     = CardColor.Any;
            CardType      targetCardType      = CardType.Attack;
            CardMovePoint targetCardMovePoint = CardMovePoint.Hand;

            gameWorldManager.CardManager.CreateRandomCard(targetCardColor, targetCardType, targetCardMovePoint, ShuffleFormat.Bottom);

            return(true);
        }
예제 #14
0
 public override bool CanUseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     foreach (var cardInHand in gameWorldManager.CardManager.Hand)
     {
         if (cardInHand.CardType != CardType.Attack)
         {
             return(false);
         }
     }
     return(true);
 }
예제 #15
0
        public override int CalculateCostOverridable(IGameWorldManager gameWorldManager, ICardInstance cardInstance)
        {
            var baseCost = base.CalculateCostOverridable(gameWorldManager, cardInstance);
            var newValue = Cost - (gameWorldManager.HeroManager.MetaInformation[MetaInformation.TimesPlayerGotAttacked] * 1);

            if (newValue > baseCost)
            {
                return(baseCost);
            }
            return(newValue >= 0 ? newValue : 0);
        }
예제 #16
0
        public override bool ActionWhenTriggered(IGameWorldManager gameWorldManager)
        {
            gameWorldManager.CardEffectManager.DamageTarget(BaseCard, new DamageMultipleTimesEffect()
            {
                DamageAmount = 4,
                HitTimes     = 1
            }, new List <IEnemyInstance>()
            {
                gameWorldManager.EnemyManager.ActiveEnemyInstance
            });

            return(true);
        }
예제 #17
0
        public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            foreach (var target in targets)
            {
                if (target.StatusValues[StatusEffect.Vulnerable] > 0)
                {
                    gameWorldManager.HeroManager.CurrentEnergyCount += 1;
                    gameWorldManager.CardManager.DrawFromDeck();
                }
            }

            return(true);
        }
예제 #18
0
        public bool Use(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            if (CanUse(gameWorldManager, targets, cardTargets))
            {
                ActivateEffects(gameWorldManager, targets, cardTargets);
                var result = UseOverridable(gameWorldManager, targets, cardTargets);
                gameWorldManager.GameTurnManager.ActivateAvailablePowerTriggers(PowerTrigger.Always);

                if (this.CardType == CardType.Attack)
                {
                    gameWorldManager.GameTurnManager.ActivateActiveSkillCardsThisTurn(ActiveSkillTrigger.OnAttack);
                }

                return(result);
            }
            return(false);
        }
예제 #19
0
        public virtual int CalculateCostOverridable(IGameWorldManager gameWorldManager, ICardInstance cardInstance)
        {
            //TODO: actually calculate shit here

            // In case of CorruptionPower:
            if (CardType == CardType.Skill)
            {
                var hasCorruption = gameWorldManager.HeroManager.ActivePowerCards.Any(x => x.UniquePowerId == new Guid("05bbe85a-f7da-4555-a7cc-cc60bbc21bed"));
                if (hasCorruption)
                {
                    return(0);
                }
            }

            var calculatedCost = Cost;

            return(calculatedCost);
        }
예제 #20
0
        public override bool UseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
        {
            var potentialCopy = gameWorldManager.CardManager.DeckPile.FirstOrDefault(x => x.UniqueCardId == new Guid("3c27f381-00a0-415a-97ab-1d18337bbfaf"));

            if (potentialCopy != null)
            {
                gameWorldManager.CardManager.MoveCardBetweenPiles(potentialCopy, CardMovePoint.Deck, CardMovePoint.DiscardPile);
            }
            else
            {
                var potentialCopyFromHand = gameWorldManager.CardManager.Hand.FirstOrDefault(x => x.UniqueCardId == new Guid("3c27f381-00a0-415a-97ab-1d18337bbfaf"));
                if (potentialCopyFromHand != null)
                {
                    gameWorldManager.CardManager.MoveCardBetweenPiles(potentialCopyFromHand, CardMovePoint.Hand, CardMovePoint.DiscardPile);
                }
            }
            return(true);
        }
예제 #21
0
 public override bool ActionWhenTriggered(IGameWorldManager gameWorldManager)
 {
     foreach (var cardInstance in gameWorldManager.CardManager.Hand.Where(x => x.CardType == CardType.Skill))
     {
         cardInstance.ActualCost           = 0;
         cardInstance.BaseCard.CardUseType = CardUseType.Exhaust;
     }
     foreach (var cardInstance in gameWorldManager.CardManager.DeckPile.Where(x => x.CardType == CardType.Skill))
     {
         cardInstance.ActualCost           = 0;
         cardInstance.BaseCard.CardUseType = CardUseType.Exhaust;
     }
     foreach (var cardInstance in gameWorldManager.CardManager.DiscardPile.Where(x => x.CardType == CardType.Skill))
     {
         cardInstance.ActualCost           = 0;
         cardInstance.BaseCard.CardUseType = CardUseType.Exhaust;
     }
     foreach (var cardInstance in gameWorldManager.CardManager.ExhaustPile.Where(x => x.CardType == CardType.Skill))
     {
         cardInstance.ActualCost           = 0;
         cardInstance.BaseCard.CardUseType = CardUseType.Exhaust;
     }
     return(true);
 }
예제 #22
0
 public HeroManager(IGameWorldManager gameWorldManager)
 {
     _gameWorldManager = gameWorldManager;
 }
예제 #23
0
 public override bool ShouldTrigger(IGameWorldManager gameWorldManager)
 {
     return(true);
 }
예제 #24
0
 public void AfterTurnCountEventOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     gameWorldManager.CardEffectManager.AddStrengthSelf(-2);
 }
예제 #25
0
        public override bool ActionWhenTriggered(IGameWorldManager gameWorldManager)
        {
            gameWorldManager.CardManager.DrawFromDeck();

            return(true);
        }
예제 #26
0
 public override bool ShouldTrigger(IGameWorldManager gameWorldManager)
 {
     return(gameWorldManager.CardManager.LastCardPick != null && gameWorldManager.CardManager.LastCardPick.CardType == CardType.Status);
 }
예제 #27
0
 public GameTurnManager(IGameWorldManager gameWorldManager)
 {
     _gameWorldManager = gameWorldManager;
 }
예제 #28
0
 public override int CalculateDamageOverridable(IGameWorldManager gameWorldManager, int baseDamage, IEnemyInstance target)
 {
     return(baseDamage + (gameWorldManager.HeroManager.StatusValues[StatusEffect.Strength] * 3));
 }
예제 #29
0
 public override bool CanUseOverridable(IGameWorldManager gameWorldManager, List <IEnemyInstance> targets, List <ICardInstance> cardTargets)
 {
     return(false);
 }
예제 #30
0
 public EnemyManager(IGameWorldManager gameWorldManager)
 {
     _gameWorldManager = gameWorldManager;
 }