Example #1
0
 static bool Prefix(ActivatableAbility ability, ref UnitCommand.CommandType __result)
 {
     if (Mod.Enabled && FixActionTypeOfBardicPerformance)
     {
         if (ability.Blueprint.Group == ActivatableAbilityGroup.BardicPerformance)
         {
             if (ability.Owner.State.Features.QuickenPerformance2)
             {
                 __result = ability.Owner.State.Features.SingingSteel ?
                            UnitCommand.CommandType.Free : UnitCommand.CommandType.Swift;
             }
             else if (ability.Owner.State.Features.QuickenPerformance1)
             {
                 __result = ability.Owner.State.Features.SingingSteel ?
                            UnitCommand.CommandType.Swift : UnitCommand.CommandType.Move;
             }
             else
             {
                 __result = ability.Owner.State.Features.SingingSteel ?
                            UnitCommand.CommandType.Move : UnitCommand.CommandType.Standard;
             }
         }
         else
         {
             __result = ability.Blueprint.ActivateWithUnitCommandType;
         }
         return(false);
     }
     return(true);
 }
Example #2
0
 public static void Prefix(ref bool value, ActivatableAbility __instance)
 {
     if (settings.toggleAllowAllActivatable && __instance.Blueprint.Group == ActivatableAbilityGroup.Judgment)
     {
         value = true;
     }
 }
        static void Postfix(ActivatableAbility __instance, ref bool __result)
        {
            if (__result == false)
            {
                return;
            }

            __result = !(__instance.Owner.Get <UnitPartUnableToUseAbilities>()?.active()).GetValueOrDefault();
        }
 static bool Prefix(ActivatableAbility __instance)
 {
     if (combatManeuverToggleAbilityBlueprintGuids.Contains(__instance.Blueprint.AssetGuid))
     {
         ActivatableAbility[] array = (from a in __instance.Owner.ActivatableAbilities.Enumerable
                                       where a.IsOn &&
                                       a != __instance &&
                                       combatManeuverToggleAbilityBlueprintGuids.Contains(a.Blueprint.AssetGuid)
                                       select a).ToArray();
         foreach (var toggle in array)
         {
             toggle.IsOn = false;
         }
     }
     return(true);
 }
Example #5
0
            static void Postfix(ActivatableAbility __instance)
            {
                if (__instance.Blueprint.Group != ActivatableAbilityGroup.BardicPerformance)
                {
                    return;
                }

                var activated_performances = __instance.Owner.ActivatableAbilities.Enumerable.Where(a => __instance.Owner.Buffs.HasFact(a.Blueprint.Buff) && !a.IsOn &&
                                                                                                    a.Blueprint.Group == ActivatableAbilityGroup.BardicPerformance);

                foreach (var a in activated_performances)
                {
                    if (a != __instance)
                    {
                        (__instance.Owner.Buffs.GetFact(a.Blueprint.Buff) as Buff).Remove();
                    }
                }
            }
Example #6
0
 static bool Prefix(ActivatableAbility ability, ref UnitCommand.CommandType __result)
 {
     if (ability.Blueprint.Group != ActivatableAbilityGroup.BardicPerformance)
     {
         __result = ability.Owner.Ensure <UnitPartActivatableAbilityActionTypeModifier>().getCommandType(ability.Blueprint);
     }
     else if ((bool)ability.Owner.State.Features.QuickenPerformance2 || ability.Blueprint.ActivateWithUnitCommandType == UnitCommand.CommandType.Swift)
     {
         __result = !(bool)ability.Owner.State.Features.SingingSteel ? UnitCommand.CommandType.Swift : UnitCommand.CommandType.Free;
     }
     else if ((bool)ability.Owner.State.Features.QuickenPerformance1 || ability.Blueprint.ActivateWithUnitCommandType == UnitCommand.CommandType.Move)
     {
         __result = !(bool)ability.Owner.State.Features.SingingSteel ? UnitCommand.CommandType.Move : UnitCommand.CommandType.Swift;
     }
     else
     {
         __result = !(bool)ability.Owner.State.Features.SingingSteel ? UnitCommand.CommandType.Standard : UnitCommand.CommandType.Move;
     }
     return(false);
 }
Example #7
0
 public UnitDeactivateAbility(ActivatableAbility ability)
     : base(CommandType.Free, null)
 {
     activatable_ability = ability;
 }
        public static BlueprintScriptableObject[] Tooltip()
        {
            TooltipData contextTooltipData = Game.Instance.UI.TooltipsController.ContextTooltipData;

            if (contextTooltipData == null)
            {
                return((BlueprintScriptableObject[])null);
            }
            ItemEntity itemEntity = contextTooltipData.Item;

            if (itemEntity != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)itemEntity.Blueprint
                       }
            }
            ;
            BlueprintFeatureBase feature = contextTooltipData.Feature;

            if (feature != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)feature
                       }
            }
            ;
            Ability ability = contextTooltipData.Ability;

            if (ability != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)ability.Blueprint
                       }
            }
            ;
            BlueprintFeatureSelection featureSelection = contextTooltipData.FeatureSelection;

            if (featureSelection != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)featureSelection
                       }
            }
            ;
            AbilityData abilityData = contextTooltipData.AbilityData;

            if (abilityData != (AbilityData)null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)abilityData.Blueprint
                       }
            }
            ;
            ActivatableAbility activatableAbility = contextTooltipData.ActivatableAbility;

            if (activatableAbility != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)activatableAbility.Blueprint
                       }
            }
            ;
            Buff buff = contextTooltipData.Buff;

            if (buff != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)buff.Blueprint
                       }
            }
            ;
            BlueprintAbility blueprintAbility = contextTooltipData.BlueprintAbility;

            if (blueprintAbility != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)blueprintAbility
                       }
            }
            ;
            BlueprintCookingRecipe recipe = contextTooltipData.Recipe;

            if (recipe != (UnityEngine.Object)null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)recipe
                       }
            }
            ;
            KingdomBuff kingdomBuff = contextTooltipData.KingdomBuff;

            if (kingdomBuff != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)kingdomBuff.Blueprint
                       }
            }
            ;
            UnitEntityData unit = contextTooltipData.Unit;

            if (unit != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)unit.Blueprint
                       }
            }
            ;
            BlueprintCharacterClass blueprintCharacterClass = contextTooltipData.Class;

            if (blueprintCharacterClass != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)blueprintCharacterClass
                       }
            }
            ;
            BlueprintRace race = contextTooltipData.Race;

            if (race != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)race
                       }
            }
            ;
            BlueprintSettlementBuilding settlementBuildingBp = contextTooltipData.SettlementBuildingBp;

            if (settlementBuildingBp != null)
            {
                return new BlueprintScriptableObject[1]
                       {
                           (BlueprintScriptableObject)settlementBuildingBp
                       }
            }
            ;
            SettlementBuilding settlementBuilding = contextTooltipData.SettlementBuilding;

            if (settlementBuilding == null)
            {
                return((BlueprintScriptableObject[])contextTooltipData.TutorialPage ?? (BlueprintScriptableObject[])null);
            }
            return(new BlueprintScriptableObject[1]
            {
                (BlueprintScriptableObject)settlementBuilding.Blueprint
            });
        }
    }
}