Example #1
0
        public void ProcessDrawnDamageCard(GenericDamageCard damageCard, EventArgs e)
        {
            AssignedDamageDiceroll.CancelHits(1);

            Combat.CurrentCriticalHitCard = damageCard;

            if (Combat.CurrentCriticalHitCard.IsFaceup)
            {
                if (OnFaceupCritCardReadyToBeDealt != null)
                {
                    OnFaceupCritCardReadyToBeDealt(this, Combat.CurrentCriticalHitCard);
                }

                if (OnFaceupCritCardReadyToBeDealtGlobal != null)
                {
                    OnFaceupCritCardReadyToBeDealtGlobal(this, Combat.CurrentCriticalHitCard);
                }

                Triggers.RegisterTrigger(new Trigger
                {
                    Name         = "Information about faceup damage card",
                    TriggerOwner = this.Owner.PlayerNo,
                    TriggerType  = TriggerTypes.OnFaceupCritCardReadyToBeDealtUI,
                    EventHandler = InformCrit.LoadAndShow
                });

                Triggers.ResolveTriggers(TriggerTypes.OnFaceupCritCardReadyToBeDealt, SufferFaceupDamageCard);
            }
            else
            {
                CallOnDamageCardIsDealt(Damage.DealDrawnCard);
            }
        }
Example #2
0
        public void SufferHullDamage(bool isFaceup, EventArgs e)
        {
            AssignedDamageDiceroll.CancelHits(1);

            if (DebugManager.DebugAllDamageIsCrits)
            {
                isFaceup = true;
            }

            DamageDecks.DrawDamageCard(Owner.PlayerNo, isFaceup, ProcessDrawnDamageCard, e);
        }
Example #3
0
        public void SufferHullDamage(bool isCritical)
        {
            if (DebugManager.DebugAllDamageIsCrits)
            {
                isCritical = true;
            }

            if (isCritical)
            {
                Combat.CurrentCriticalHitCard = CriticalHitsDeck.GetCritCard();

                //if (DebugManager.DebugDamage) Debug.Log("+++ Crit: " + Combat.CurrentCriticalHitCard.Name);
                //if (DebugManager.DebugDamage) Debug.Log("+++ Source: " + (e as DamageSourceEventArgs).Source);
                //if (DebugManager.DebugDamage) Debug.Log("+++ DamageType: " + (e as DamageSourceEventArgs).DamageType);

                if (OnFaceupCritCardReadyToBeDealt != null)
                {
                    OnFaceupCritCardReadyToBeDealt(this, ref Combat.CurrentCriticalHitCard);
                }

                if (OnFaceupCritCardReadyToBeDealtGlobal != null)
                {
                    OnFaceupCritCardReadyToBeDealtGlobal(this, ref Combat.CurrentCriticalHitCard);
                }

                if (OnAssignCrit != null)
                {
                    OnAssignCrit(this, ref Combat.CurrentCriticalHitCard);
                }

                if (Combat.CurrentCriticalHitCard != null)
                {
                    AssignedCritCards.Add(Combat.CurrentCriticalHitCard);
                    DecreaseHullValue();
                    Combat.CurrentCriticalHitCard.AssignCrit(this);
                }
                else
                {
                    Triggers.FinishTrigger();
                }
            }
            else
            {
                AssignedDamageCards.Add(CriticalHitsDeck.GetCritCard());
                DecreaseHullValue();
                Triggers.FinishTrigger();
            }

            AssignedDamageDiceroll.CancelHits(1);
        }
Example #4
0
        public void SufferHullDamage(bool isCritical, EventArgs e)
        {
            AssignedDamageDiceroll.CancelHits(1);

            if (DebugManager.DebugAllDamageIsCrits)
            {
                isCritical = true;
            }

            if (isCritical)
            {
                CriticalHitsDeck.GetCritCard(isCritical, delegate { SufferChosenCriticalHitCard(e); });
            }
            else
            {
                CriticalHitsDeck.GetCritCard(isCritical, delegate { CallOnDamageCardIsDealt(DealRegularDamageCard); });
            }
        }
Example #5
0
        public void SufferHullDamage(bool isCritical, EventArgs e)
        {
            AssignedDamageDiceroll.CancelHits(1);

            if (DebugManager.DebugAllDamageIsCrits)
            {
                isCritical = true;
            }

            if (isCritical)
            {
                Combat.CurrentCriticalHitCard = CriticalHitsDeck.GetCritCard();

                if (DebugManager.DebugDamage)
                {
                    Debug.Log("+++ Crit: " + Combat.CurrentCriticalHitCard.Name);
                }

                if (OnFaceupCritCardReadyToBeDealt != null)
                {
                    OnFaceupCritCardReadyToBeDealt(this, Combat.CurrentCriticalHitCard);
                }

                if (OnFaceupCritCardReadyToBeDealtGlobal != null)
                {
                    OnFaceupCritCardReadyToBeDealtGlobal(this, Combat.CurrentCriticalHitCard, e);
                }

                Triggers.RegisterTrigger(new Trigger
                {
                    Name         = "Information about faceup damage card",
                    TriggerOwner = this.Owner.PlayerNo,
                    TriggerType  = TriggerTypes.OnFaceupCritCardReadyToBeDealtUI,
                    EventHandler = delegate { InformCrit.LoadAndShow(); }
                });

                Triggers.ResolveTriggers(TriggerTypes.OnFaceupCritCardReadyToBeDealt, SufferFaceupDamageCard);
            }
            else
            {
                Combat.CurrentCriticalHitCard = CriticalHitsDeck.GetCritCard();
                CallOnDamageCardIsDealt(DealRegularDamageCard);
            }
        }
Example #6
0
    public static void CalculateAttackResults(Ship.GenericShip attacker, Ship.GenericShip defender)
    {
        DiceRollAttack.CancelHits(DiceRollDefence.Successes);
        DiceRollAttack.RemoveAllFailures();

        if (DiceRollAttack.Successes > 0)
        {
            Attacker.CallOnAttackHitAsAttacker();
            Defender.CallOnAttackHitAsDefender();

            Triggers.ResolveTriggers(TriggerTypes.OnAttackHit, delegate { ResolveCombatDamage(SufferDamage); });
        }
        else
        {
            SufferDamage();
        }
    }
Example #7
0
    public static void CancelHitsByDefenceDice()
    {
        int crits = DiceRollAttack.CriticalSuccesses;

        DiceRollAttack.CancelHits(DiceRollDefence.Successes);
        if (crits > DiceRollAttack.CriticalSuccesses)
        {
            Attacker.CallOnAtLeastOneCritWasCancelledByDefender();
            Triggers.ResolveTriggers(
                TriggerTypes.OnAtLeastOneCritWasCancelledByDefender,
                delegate
            {
                CalculateAttackResults();
            });
        }
        else
        {
            CalculateAttackResults();
        }
    }
Example #8
0
    public static void CalculateAttackResults(Ship.GenericShip attacker, Ship.GenericShip defender)
    {
        DiceRollAttack.CancelHits(DiceRollDefence.Successes);
        DiceRollAttack.RemoveAllFailures();

        if (DiceRollAttack.Successes > 0)
        {
            defender.AssignedDamageDiceroll = DiceRollAttack;

            foreach (var dice in DiceRollAttack.DiceList)
            {
                Triggers.RegisterTrigger(new Trigger()
                {
                    Name         = "Suffer damage",
                    TriggerType  = TriggerTypes.OnDamageIsDealt,
                    TriggerOwner = defender.Owner.PlayerNo,
                    EventHandler = defender.SufferDamage,
                    Skippable    = true
                });
            }
        }

        SufferDamage();
    }