public override void RunAction()
 {
     if (this.Context.MaybeCaster == null)
     {
         UberDebug.LogError((object)"Caster unit is missing", (object[])Array.Empty <object>());
     }
     else
     {
         int num = bonus.Calculate(this.Context);
         var rule_skill_check = new RuleSkillCheck(this.Context.MaybeCaster, this.Stat, this.UseCustomDC ? this.CustomDC.Calculate(this.Context) : ((this.Target.Unit?.Descriptor?.Progression.CharacterLevel).GetValueOrDefault() + 10));
         rule_skill_check.ShowAnyway = true;
         if (num != 0)
         {
             rule_skill_check.Bonus.AddModifier(num, null, Kingmaker.Enums.ModifierDescriptor.UntypedStackable);
         }
         if (this.Context.TriggerRule <RuleSkillCheck>(rule_skill_check).IsPassed)
         {
             this.Success.Run();
         }
         else
         {
             this.Failure.Run();
         }
     }
 }
        public override void RunAction()
        {
            var target    = this.Target.Unit;
            var initiator = this.Context.MaybeCaster;

            if (!InspectUnitsHelper.IsInspectAllow(target))
            {
                return;
            }


            BlueprintUnit blueprintForInspection = target.Descriptor.BlueprintForInspection;

            InspectUnitsManager.UnitInfo info = Game.Instance.Player.InspectUnitsManager.GetInfo(blueprintForInspection);
            StatType statType = !(bool)((UnityEngine.Object)info.Blueprint.Type) ? StatType.SkillLoreNature : info.Blueprint.Type.KnowledgeStat;


            if (info == null)
            {
                return;
            }

            ModifiableValueSkill stat = initiator.Stats.GetStat <ModifiableValueSkill>(statType);
            int?nullable1;
            int?nullable2;

            if (stat == null)
            {
                nullable1 = new int?();
                nullable2 = nullable1;
            }
            else
            {
                nullable2 = new int?(stat.BaseValue);
            }
            nullable1 = nullable2;

            int dc    = info.DC;
            int bonus = value.Calculate(this.Context);

            if ((!nullable1.HasValue ? 0 : nullable1.Value) > 0 || (bool)initiator.Descriptor.State.Features.MakeKnowledgeCheckUntrained)
            {
                var skill_check = new RuleSkillCheck(initiator, statType, dc);
                skill_check.AddTemporaryModifier(initiator.Stats.GetStat(statType).AddModifier(bonus, null, descriptor));
                skill_check.IgnoreDifficultyBonusToDC = true;
                int rollResult = Rulebook.Trigger <RuleSkillCheck>(skill_check).RollResult;
                Common.AddBattleLogMessage($"{initiator.CharacterName} DC {dc} monster lore check: {rollResult}");

                if (dc <= rollResult && action_on_success != null)
                {
                    action_on_success.Run();
                }
                if (info.KnownPartsCount < 4)
                {
                    info.SetCheck(rollResult, initiator);
                    EventBus.RaiseEvent <IKnowledgeHandler>((Action <IKnowledgeHandler>)(h => h.HandleKnowledgeUpdated(info)));
                }
            }
        }
        static bool Prefix(RulePartySkillCheck __instance, bool isTrigger, ref int ___m_D20, ref int ___m_StatValue, StatType ___m_StatType, int ___m_DifficultyClass)
        {
            ___m_StatValue = int.MinValue;
            var tr = Harmony12.Traverse.Create(__instance);

            tr.Property("Roller").SetValue(null);
            RuleSkillCheck selected_evt = null;

            foreach (UnitEntityData unitEntityData in Game.Instance.Player.Party)
            {
                if (unitEntityData.Descriptor.State.CanAct)
                {
                    ModifiableValue stat = unitEntityData.Stats.GetStat(___m_StatType);
                    ModifiableValueAttributeStat valueAttributeStat = stat as ModifiableValueAttributeStat;
                    int            num = valueAttributeStat != null ? valueAttributeStat.Bonus : stat.ModifiedValue;
                    RuleSkillCheck evt = new RuleSkillCheck(unitEntityData, ___m_StatType, ___m_DifficultyClass)
                    {
                        Voice         = __instance.Voice,
                        EnsureSuccess = __instance.EnsureSuccess
                    };

                    if (isTrigger)
                    {
                        evt.Silent = true;;
                        Rulebook.Trigger <RuleSkillCheck>(evt);
                        num += (int)evt.Bonus;
                    }

                    if (___m_StatValue < num)
                    {
                        ___m_StatValue = num;
                        tr.Property("Roller").SetValue(unitEntityData);
                        selected_evt = evt;
                    }
                }
            }
            if (__instance.Roller == null)
            {
                UberDebug.Log("Roller is null, in the party skillcheck", (object[])Array.Empty <object>());
            }
            else
            {
                if (!isTrigger)
                {
                    selected_evt.Calculate();
                }
                else
                {
                    selected_evt.Silent = false;
                    EventBus.RaiseEvent <IRollSkillCheckHandler>((Action <IRollSkillCheckHandler>)(h => h.HandleOnRuleSkillCheck(selected_evt)));
                    //Game.Instance?.UI?.BattleLogManager?.HandleUnitSkillCheckRolled(selected_evt);
                }
                ___m_D20 = selected_evt.D20;
            }
            return(false);
        }
 public void OnEventAboutToTrigger(RuleSkillCheck evt)
 {
     // If this was triggered from a party rule, remove the temporary bonuses before rolling.
     if (Modifiers == null)
     {
         return;
     }
     Modifiers.ForEach(m => m.Remove());
     Modifiers = null;
 }
 static private int getD20Value(RuleSkillCheck evt)
 {
     if (evt.IsTriggererd)
     {
         return(evt.D20 + evt.Bonus);
     }
     else
     {
         return(evt.D20);
     }
 }
예제 #6
0
 private static void Postfix(ref bool __result, RuleSkillCheck __instance)
 {
     if (settings.toggleNoFriendlyFireForAOE)
     {
         if (__instance.Reason != null)
         {
             if (__instance.Reason.Ability != null)
             {
                 if (__instance.Reason.Caster != null && __instance.Reason.Caster.IsPlayerFaction && __instance.Initiator.IsPlayerFaction && __instance.Reason.Ability.Blueprint != null && ((__instance.Reason.Ability.Blueprint.EffectOnAlly == AbilityEffectOnUnit.Harmful) || (__instance.Reason.Ability.Blueprint.EffectOnEnemy == AbilityEffectOnUnit.Harmful)))
                 {
                     __result = true;
                 }
             }
         }
     }
 }
예제 #7
0
        private static bool tryBreakFree(UnitEntityData target, UnitEntityData grappler, MechanicsContext context)
        {
            int dc = 0;

            if (context != null)
            {
                dc = context.Params.DC;
            }
            RuleCalculateCMB rule_calcualte_cmb1 = new RuleCalculateCMB(target, grappler, CombatManeuver.Grapple);
            RuleCalculateCMB rule_calcualte_cmb2 = context?.TriggerRule <RuleCalculateCMB>(rule_calcualte_cmb1) ?? Rulebook.Trigger <RuleCalculateCMB>(rule_calcualte_cmb1);

            if (Math.Max((int)(target.Stats.SkillMobility), (int)(target.Stats.SkillAthletics)) < rule_calcualte_cmb2.Result)
            {
                RuleSkillCheck rule_skill_check = new RuleSkillCheck(target, StatType.AdditionalCMB, dc);
                rule_skill_check.Bonus.AddModifier(rule_calcualte_cmb2.Result - target.Stats.AdditionalCMB.ModifiedValue, null, ModifierDescriptor.UntypedStackable);
                return((context?.TriggerRule <RuleSkillCheck>(rule_skill_check) ?? Rulebook.Trigger <RuleSkillCheck>(rule_skill_check)).IsPassed);
            }
            else
            {
                StatType       stat             = (int)(target.Stats.SkillMobility) > (int)(target.Stats.SkillAthletics) ? StatType.SkillMobility : StatType.SkillAthletics;
                RuleSkillCheck rule_skill_check = new RuleSkillCheck(target, stat, dc);
                return((context?.TriggerRule <RuleSkillCheck>(rule_skill_check) ?? Rulebook.Trigger <RuleSkillCheck>(rule_skill_check)).IsPassed);
            }
        }
예제 #8
0
 public void OnEventDidTrigger(RuleSkillCheck evt)
 {
 }
예제 #9
0
 public void OnEventAboutToTrigger(RuleSkillCheck evt) => IncreaseLuckBonus(evt, evt.StatType);
        static bool Prefix(Demoralize __instance)
        {
            var tr     = Harmony12.Traverse.Create(__instance);
            var target = tr.Property("Target").GetValue <TargetWrapper>();

            MechanicsContext.Data data             = ElementsContext.GetData <MechanicsContext.Data>();
            MechanicsContext      mechanicsContext = (data != null) ? data.Context : null;
            UnitEntityData        unitEntityData   = (mechanicsContext != null) ? mechanicsContext.MaybeCaster : null;

            if (unitEntityData == null || !target.IsUnit)
            {
                UberDebug.LogError(__instance, "Unable to apply buff: no context found", Array.Empty <object>());
                return(false);
            }
            int num = 10 + target.Unit.Descriptor.Progression.CharacterLevel + target.Unit.Stats.Wisdom.Bonus;

            ModifiableValue.Modifier modifier = null;
            try
            {
                if (__instance.DazzlingDisplay && unitEntityData.Descriptor.State.Features.SwordlordWeaponProwess)
                {
                    int num2 = 0;
                    foreach (var feature in unitEntityData.Descriptor.Progression.Features)
                    {
                        var  param = feature.Param;
                        bool flag;
                        if (param == null)
                        {
                            flag = false;
                        }
                        else
                        {
                            WeaponCategory?weaponCategory  = param.WeaponCategory;
                            WeaponCategory weaponCategory2 = WeaponCategory.DuelingSword;
                            flag = (weaponCategory.GetValueOrDefault() == weaponCategory2 & weaponCategory != null);
                        }
                        if (flag)
                        {
                            num2++;
                        }
                    }
                    modifier = unitEntityData.Stats.CheckIntimidate.AddModifier(num2, null, ModifierDescriptor.None);
                }
                var ruleSkillCheck        = new RuleSkillCheck(unitEntityData, StatType.CheckIntimidate, num);
                var demoralize_bonus_part = mechanicsContext.MaybeCaster.Get <UnitPartDemoralizeBonus>();
                if (demoralize_bonus_part != null)
                {
                    ruleSkillCheck.Bonus.AddModifier(demoralize_bonus_part.getBonus(), null, ModifierDescriptor.UntypedStackable);
                }

                ruleSkillCheck = mechanicsContext.TriggerRule <RuleSkillCheck>(ruleSkillCheck);
                if (ruleSkillCheck.IsPassed)
                {
                    int num3 = 1 + (ruleSkillCheck.RollResult - num) / 5 + (unitEntityData.Descriptor.State.Features.FrighteningThug ? 1 : 0);
                    if (unitEntityData.Descriptor.State.Features.FrighteningThug && num3 >= 4)
                    {
                        target.Unit.Descriptor.AddBuff(__instance.GreaterBuff, mechanicsContext, new TimeSpan?(1.Rounds().Seconds));
                    }
                    Buff buff = target.Unit.Descriptor.AddBuff(__instance.Buff, mechanicsContext, new TimeSpan?(num3.Rounds().Seconds));
                    if (unitEntityData.Descriptor.HasFact(__instance.ShatterConfidenceFeature) && buff != null)
                    {
                        Buff fact = target.Unit.Descriptor.AddBuff(__instance.ShatterConfidenceBuff, mechanicsContext, new TimeSpan?(num3.Rounds().Seconds));
                        buff.StoreFact(fact);
                    }

                    unitEntityData.Get <UnitPartActionOnDemoralize>()?.runActions(mechanicsContext, target.Unit, num, ruleSkillCheck.RollResult);
                    var scoped_actions = (mechanicsContext?.SourceAbility?.GetComponents <ScopedDemoralizeActions>()).EmptyIfNull();
                    foreach (var s in scoped_actions)
                    {
                        s.actions.Run();
                    }
                }
            }
            finally
            {
                if (modifier != null)
                {
                    modifier.Remove();
                }
            }
            return(false);
        }