public static void Postfix(SGBarracksSkillPip __instance, string type, int index, bool hasPassives, AbilityDef ability)
{
if (!hasPassives)
{
return;
}
SimGameState simGameState = LazySingletonBehavior <UnityGameInstance> .Instance.Game.Simulation;
if (simGameState == null)
{
return;
}
// Get the abilities that are not primary
List <AbilityDef> abilities = simGameState.GetAbilityDefFromTree(type, index).Where(x => !x.IsPrimaryAbility).ToList();
// Gets the first ability that has a tooltip
AbilityDef passiveAbility = abilities.Find(x => x.DisplayParams == AbilityDef.DisplayParameters.ShowInPilotToolTip && !(string.IsNullOrEmpty(x.Description.Name) || string.IsNullOrEmpty(x.Description.Details)));
// Clear the dot on tooltip-less dots
if (passiveAbility == null)
{
Traverse.Create(__instance).Field("skillPassiveTraitDot").GetValue <SVGImage>().gameObject.SetActive(false);
}
if (passiveAbility != null)
{
__instance.gameObject.FindFirstChildNamed("obj-pip").GetComponent <HBSTooltip>().SetDefaultStateData(TooltipUtilities.GetStateDataFromObject(passiveAbility.Description));
}
}
public override void PostAbilityAttempt(Pawn caster, AbilityDef ability)
{
ForceAbilityDef forceDef = ability as ForceAbilityDef;
if (forceDef != null)
{
if (forceDef.changedAlignmentType != ForceAlignmentType.None)
{
//Log.Message("Alignment: " + AlignmentValue.ToStringPercent());
//Log.Message("Alignment Change: " + forceDef.changedAlignmentRate.ToStringPercent());
AlignmentValue += forceDef.changedAlignmentRate;
//Log.Message("New Alignment: " + AlignmentValue.ToStringPercent());
UpdateAlignment();
}
if (ForcePool != null)
{
float poolCost = 0f;
//Log.Message("PC" + forceDef.forcePoolCost.ToString());
poolCost = forceDef.forcePoolCost - (forceDef.forcePoolCost * (0.15f * (float)ForceSkillLevel("PJ_ForcePool")));
//Log.Message("PC" + poolCost.ToString());
ForcePool.UseForcePower(poolCost);
}
}
}
private string GetTitle()
{
if (thing != null)
{
return(thing.LabelCapNoCount);
}
if (worldObject != null)
{
return(worldObject.LabelCap);
}
ThingDef thingDef = Def as ThingDef;
if (thingDef != null)
{
return(GenLabel.ThingLabel(thingDef, stuff).CapitalizeFirst());
}
AbilityDef abilityDef = Def as AbilityDef;
if (abilityDef != null)
{
return(abilityDef.LabelCap);
}
if (titleDef != null)
{
return(titleDef.GetLabelCapForBothGenders());
}
if (faction != null)
{
return(faction.Name);
}
return(Def.LabelCap);
}
public AbilityDef GetAbilityDef(int index)
{
try
{
return(this.TMabilityDefs[index]);
}
catch
{
return(this.TMabilityDefs[0]);
}
//
AbilityDef result = null;
bool flag = this.TMabilityDefs != null && this.TMabilityDefs.Count > 0;
if (flag)
{
result = this.TMabilityDefs[0];
bool flag2 = index > -1 && index < this.TMabilityDefs.Count;
if (flag2)
{
result = this.TMabilityDefs[index];
}
else
{
bool flag3 = index >= this.TMabilityDefs.Count;
if (flag3)
{
result = this.TMabilityDefs[this.TMabilityDefs.Count - 1];
}
}
}
return(result);
}
public override void DoSettingsWindowContents(Rect inRect)
{
base.DoSettingsWindowContents(inRect);
var psycasts = DefDatabase<AbilityDef>.AllDefsListForReading;
foreach (var psycast in psycasts)
{
if (settings.psycastStates == null) settings.psycastStates = new Dictionary<string, bool>();
if (!settings.psycastStates.ContainsKey(psycast.defName))
{
settings.psycastStates[psycast.defName] = true;
}
}
var morePsycasts_psycasts = typeof(PsycastDefOf).GetFields();
foreach (var psycast in morePsycasts_psycasts)
{
if (settings.psycastStats == null) settings.psycastStats = new Dictionary<string, List<float>>();
AbilityDef current = DefDatabase<AbilityDef>.GetNamed(psycast.Name);
if (!settings.psycastStats.ContainsKey(current.defName))
{
List<float> currentList = new List<float>();
currentList.Add(current.statBases.GetStatValueFromList(StatDefOf.Ability_EntropyGain, 0));
currentList.Add(current.statBases.GetStatValueFromList(StatDefOf.Ability_PsyfocusCost, 0));
currentList.Add(current.statBases.GetStatValueFromList(StatDefOf.Ability_Duration, 0));
settings.psycastStats[current.defName] = currentList;
}
}
settings.DoSettingsWindowContents(inRect);
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
Brain brain = pawn.pawn.GetSquadBrain();
if (brain == null)
{
return(false);
}
MapComponent_Ability mapComponent = MapComponent_Ability.GetOrCreate();
foreach (Pawn p in brain.ownedPawns)
{
if (p.def.defName == "Ant_Queen")
{
return(false);
}
Saveable_Caster save;
if (mapComponent.TryGetPawnHability(p, out save))
{
if ((save.currentAbility != null) &&
(save.currentAbility.defName == "AlienEvolveToPrincessAbility"))
{
return(false);
}
}
}
return(true);
}
void PopulateAbilityMenuPanes()
{
// Populate abilities
GameObject abilityPane = GameObject.Find("Abilities Pane");
int numAbilities = abilityConstants.ABILITYLIST.Count;
for (int i = 0; i < numAbilities; i++)
{
AbilityDef ability = abilityConstants.ABILITYLIST[i];
GameObject abilityButton = Instantiate(abilityButtonPrefab, abilityPane.transform);
abilityButton.name = ability.aName;
abilityButton.GetComponent <Image>().sprite = ability.aSprite;
abilityButton.GetComponent <ButtonProps>().index = i;
}
// Populate modifiers
GameObject modifierPane = GameObject.Find("Modifiers Pane");
int numModifiers = abilityConstants.MODIFIERLIST.Count;
for (int i = 0; i < numModifiers; i++)
{
ModifierDef modifier = abilityConstants.MODIFIERLIST[i];
GameObject modifierButton = Instantiate(modifierButtonPrefab, modifierPane.transform);
modifierButton.name = modifier.mName;
Image buttonImage = modifierButton.GetComponent <Image>();
buttonImage.sprite = modifier.mSprite;
buttonImage.color = modifier.mColor;
modifierButton.GetComponent <ButtonProps>().index = i;
}
}
/// <summary>
/// Gets the mutagenic entropy gain from this ability def.
/// </summary>
/// <param name="def">The definition.</param>
/// <returns></returns>
public static float GetMutagenicEntropyGain([NotNull] this AbilityDef def)
{
if (def == null)
{
throw new ArgumentNullException(nameof(def));
}
return(def.statBases?.GetStatValueFromList(PCStatDefOf.Ability_MutagenicEntropyGain, 0) ?? 0);
}
public static void Prefix(int index, ref AbilityDef ability)
{
// prevent Ability icons appearing at non-tier locations
// the actual AbilityDef is going to be provided later anyway
if (index != 4 && index != 7 && ability != null)
{
Trace($"nulling {ability.ReqSkill}|{index}");
ability = null;
}
}
// internal static readonly List<AbilityDef> ModAbilities = new List<AbilityDef>();
// internal static void PopulateAbilities()
// {
// var jsonFiles = new DirectoryInfo(
// Path.Combine(modSettings.modDirectory, "Abilities")).GetFiles().ToList();
// foreach (var file in jsonFiles)
// {
// var abilityDef = new AbilityDef();
// abilityDef.FromJSON(File.ReadAllText(file.FullName));
// if (!ModAbilities.Contains(abilityDef))
// {
// ModAbilities.Add(abilityDef);
// }
// else
// {
// Log("Duplicate AbilityDef, id is " + abilityDef.Id);
// }
// }
// }
// modified copy from assembly
private static bool HasExistingAbilityAtTier(PilotDef pilotDef, AbilityDef abilityToUse)
{
var result = pilotDef.AbilityDefs.Any(x =>
x.IsPrimaryAbility == true &&
//x.ReqSkill != SkillType.NotSet &&
x.ReqSkill == abilityToUse.ReqSkill &&
x.ReqSkillLevel == abilityToUse.ReqSkillLevel);
return(result);
}
public static void RemoveDef(AbilityDef def)
{
try
{
if (DefDatabase<AbilityDef>.AllDefsListForReading.Contains(def))
{
DefDatabase<AbilityDef>.AllDefsListForReading.Remove(def);
}
}
catch { };
}
public static void Post_GetTooltip(AbilityDef __instance, Pawn pawn, ref string __result)
{
if (pawn != null)
{
bool silenced = pawn.health.hediffSet.hediffs.Any(x => x.def.HasModExtension <PsySilencerExt>());
if (silenced)
{
__result = __instance.LabelCap + ((__instance.level > 0) ? ("\n" + "Level".Translate() + " " + __instance.level) : "") + "\n\n" + __instance.description + "\n\n" + __instance.StatSummary.ToLineList(null, false);
}
}
}
public static void GainAbility(this Pawn_AbilityTracker tracker, AbilityDef def, Thing source)
{
if (!tracker.abilities.Any((Ability a) => a.def == def))
{
tracker.abilities.Add(Activator.CreateInstance(def.abilityClass, new object[]
{
tracker.pawn,
def,
source
}) as Ability);
}
}
protected override Texture2D GetIconFor(Pawn pawn)
{
AbilityDef abilityDef = def.Ext().ability;
foreach (Ability a in pawn.abilities.abilities)
{
if (a.def == abilityDef)
{
return(abilityDef.uiIcon);
}
}
return(null);
}
public virtual IEnumerable <string> ConfigErrors(AbilityDef parentDef)
{
if (compClass == null)
{
yield return("compClass is null");
}
for (int i = 0; i < parentDef.comps.Count; i++)
{
if (parentDef.comps[i] != this && parentDef.comps[i].compClass == compClass)
{
yield return("two comps with same compClass: " + compClass);
}
}
}
public static void PrefixAbility(MethodBase __originalMethod, AbilityDef def, StatDef stat, ref Profiler __state)
{
if (Active && !GetValDetour)
{
string state = string.Empty;
if (ByDef)
{
state = $"{stat.defName} abstract for {def.defName}";
}
else
{
state = $"{stat.defName} abstract";
}
__state = ProfileController.Start(state, null, null, __originalMethod);
}
}
public static bool PrefixAbility(AbilityDef def, StatDef stat, ref string __state)
{
if (Active && !GetValDetour)
{
if (ByDef)
{
__state = $"{stat.defName} abstract for {def.defName}";
}
else
{
__state = $"{stat.defName} abstract";
}
Analyzer.Start(__state);
}
return(true);
}
public void TryGiveAbilityOfLevel(int abilityLevel)
{
string str = "LetterLabelPsylinkLevelGained".Translate() + ": " + pawn.LabelShortCap;
string text = ((abilityLevel == 1) ? "LetterPsylinkLevelGained_First" : "LetterPsylinkLevelGained_NotFirst").Translate(pawn.Named("USER"));
if (!pawn.abilities.abilities.Any((Ability a) => a.def.level == abilityLevel))
{
AbilityDef abilityDef = DefDatabase <AbilityDef> .AllDefs.Where((AbilityDef a) => a.level == abilityLevel).RandomElement();
pawn.abilities.GainAbility(abilityDef);
text += "\n\n" + "LetterPsylinkLevelGained_PsycastLearned".Translate(pawn.Named("USER"), abilityLevel, abilityDef.LabelCap);
}
if (PawnUtility.ShouldSendNotificationAbout(pawn))
{
Find.LetterStack.ReceiveLetter(str, text, LetterDefOf.PositiveEvent, pawn);
}
}
public void CastPsycast(Pawn hitPawn, Pawn sourcePawn)
{
if (Rand.Value < Props.psycastChance)
{
if (hitPawn != null & hitPawn.health != null)
{
if (sourcePawn.psychicEntropy == null)
{
sourcePawn.psychicEntropy = new Pawn_PsychicEntropyTracker(sourcePawn);
}
string psycastName = Props.psycastsToUse[Rand.Range(0, Props.psycastsToUse.Count)];
AbilityDef psycastDef = DefDatabase <AbilityDef> .GetNamed(psycastName);
Psycast psycast = new Psycast(sourcePawn, psycastDef);
psycast.Activate(hitPawn, sourcePawn);
}
}
}
// Token: 0x06002189 RID: 8585 RVA: 0x000CB488 File Offset: 0x000C9688
public override void DrawHighlight(LocalTargetInfo target)
{
AbilityDef def = this.ability.def;
this.DrawRadius();
if (this.CanHitTarget(target) && this.IsApplicableTo(target, false))
{
if (def.HasAreaOfEffect)
{
if (target.IsValid)
{
GenDraw.DrawTargetHighlight(target);
GenDraw.DrawRadiusRing(target.Cell, def.EffectRadius, Verb_CastAbility.RadiusHighlightColor, null);
}
}
else
{
GenDraw.DrawTargetHighlight(target);
}
}
if (target.IsValid)
{
this.ability.DrawEffectPreviews(target);
}
this.verbProps.DrawRadiusRing(this.caster.Position);
if (target.IsValid)
{
GenDraw.DrawTargetHighlight(target);
bool flag;
float num = this.HighlightFieldRadiusAroundTarget(out flag);
ShootLine shootLine;
if (num > 0.2f && this.TryFindShootLineFromTo(this.caster.Position, target, out shootLine))
{
if (flag)
{
GenExplosion.RenderPredictedAreaOfEffect(shootLine.Dest, num);
return;
}
GenDraw.DrawFieldEdges((from x in GenRadial.RadialCellsAround(shootLine.Dest, num, true)
where x.InBounds(Find.CurrentMap)
select x).ToList <IntVec3>());
}
}
}
internal static void PopulateAbilities()
{
var jsonFiles = new DirectoryInfo(
Path.Combine(modSettings.modDirectory, "Abilities")).GetFiles().ToList();
foreach (var file in jsonFiles)
{
var abilityDef = new AbilityDef();
abilityDef.FromJSON(File.ReadAllText(file.FullName));
if (!ModAbilities.Contains(abilityDef))
{
ModAbilities.Add(abilityDef);
}
else
{
Log("Duplicate AbilityDef, id is " + abilityDef.Id);
}
}
}
public AbilityDef GetAbilityDef(int index)
{
AbilityDef result = null;
if (abilityDefs != null && abilityDefs.Count > 0)
{
result = abilityDefs[0];
if (index > -1 && index < abilityDefs.Count)
{
result = abilityDefs[index];
}
else if (index >= abilityDefs.Count)
{
result = abilityDefs[abilityDefs.Count - 1];
}
}
return(result);
}
public static void TryExecute(CompAbilityUser casterComp, AbilityDef abilitydef, PawnAbility ability, LocalTargetInfo target, int minRange, out bool success)
{
success = false;
if (ability.CooldownTicksLeft <= 0)
{
Pawn caster = casterComp.Pawn;
LocalTargetInfo jobTarget = target;
float distanceToTarget = (jobTarget.Cell - caster.Position).LengthHorizontal;
if (distanceToTarget > minRange && distanceToTarget < (abilitydef.MainVerb.range * .9f) && jobTarget != null && jobTarget.Thing != null && Functions.Eval.HasLoSFromTo(caster.Position, jobTarget, caster, 0, abilitydef.MainVerb.range))
{
Log.Message("ability is " + ability.Def.defName + " target is " + jobTarget.Thing.LabelShort + " caster job is " + caster.CurJob);
Job job = ability.GetJob(AbilityContext.AI, jobTarget);
Log.Message("job is " + job);
job.endIfCantShootTargetFromCurPos = true;
caster.jobs.TryTakeOrderedJob(job);
success = true;
}
//a small change to test a push
}
}
public void TryGiveAbilityOfLevel_NewTemp(int abilityLevel, bool sendLetter = true)
{
string str = "LetterLabelPsylinkLevelGained".Translate() + ": " + pawn.LabelShortCap;
string text = null;
if (!pawn.abilities.abilities.Any((Ability a) => a.def.level == abilityLevel))
{
AbilityDef abilityDef = DefDatabase <AbilityDef> .AllDefs.Where((AbilityDef a) => a.level == abilityLevel).RandomElement();
pawn.abilities.GainAbility(abilityDef);
text = MakeLetterTextNewPsylinkLevel(pawn, abilityLevel, Gen.YieldSingle(abilityDef));
}
else
{
text = MakeLetterTextNewPsylinkLevel(pawn, abilityLevel);
}
if (sendLetter && PawnUtility.ShouldSendNotificationAbout(pawn))
{
Find.LetterStack.ReceiveLetter(str, text, LetterDefOf.PositiveEvent, pawn);
}
}
static void Postfix(Pilot __instance, ref List <Ability> __result)
{
Mod.Log.Trace($"AA:AA:G - entered.");
if (__instance == null || __instance.ParentActor == null)
{
return;
}
if (__instance.ParentActor.StatCollection.GetStatistic(ModStats.EnableMultiTarget).Value <bool>())
{
Mod.Log.Debug($"Pilot: {__instance} needs multi-target ability");
bool hasMultiTarget = false;
foreach (Ability ability in __result)
{
if (ability.Def.Targeting == AbilityDef.TargetingType.MultiFire)
{
hasMultiTarget = true;
}
}
if (!hasMultiTarget)
{
Traverse combatT = Traverse.Create(__instance).Property("Combat");
CombatGameState combat = combatT.GetValue <CombatGameState>();
if (combat == null)
{
return;
}
Mod.Log.Debug(" -- Adding multi-target ability to pilot.");
AbilityDef abilityDef = combat.DataManager.AbilityDefs.Get(Mod.Config.Abilities.MultiTargetId);
Ability ability = new Ability(abilityDef);
ability.Init(combat);
__result.Add(ability);
}
}
}
static void Postfix(UnitSpawnPointGameLogic __instance, AbstractActor actor, Team team, Lance lance)
{
if (actor == null || actor.GetPilot() == null)
{
Mod.Log.Info?.Write("Actor or pilot is null, cannot check for multi-targeting, skipping.");
return;
}
Statistic multiTargetStat = actor.StatCollection.GetStatistic(ModStats.EnableMultiTarget);
if (multiTargetStat != null && multiTargetStat.Value <bool>())
{
bool hasMultiTargetAbility = false;
foreach (Ability ability in actor.GetPilot().Abilities)
{
if (ability.Def.Targeting == AbilityDef.TargetingType.MultiFire)
{
Mod.Log.Debug?.Write(" -- unit already has MultiFire ability, skipping.");
hasMultiTargetAbility = true;
break;
}
}
if (!hasMultiTargetAbility)
{
Mod.Log.Debug?.Write(" -- adding multi-target ability to pilot.");
AbilityDef abilityDef = SharedState.Combat.DataManager.AbilityDefs.Get(Mod.Config.Abilities.MultiTargetId);
Ability ability = new Ability(abilityDef);
ability.Init(SharedState.Combat);
Pilot pilot = actor.GetPilot();
pilot.Abilities.Add(ability);
pilot.ActiveAbilities.Add(ability);
pilot.StatCollection.ModifyStat("", -1, ModStats.HBS_MaxTargets, StatCollection.StatOperation.Set, 3);
Mod.Log.Debug?.Write(" -- done.");
}
}
}
public static bool PawnAbility_GetJob_Prefix(PawnAbility __instance, AbilityContext context, LocalTargetInfo target, ref Job __result)
{
Job job;
Log.Message("target is " + target.Thing.LabelShort);
AbilityDef abilityDef = Traverse.Create(root: __instance).Field(name: "powerdef").GetValue <AbilityDef>();
Log.Message("ability def is " + abilityDef.defName);
Verb_UseAbility verb = Traverse.Create(root: __instance).Field(name: "verb").GetValue <Verb_UseAbility>();
Log.Message("verb is " + verb);
if (verb == null)
{
Verb_UseAbility verb_UseAbility = (Verb_UseAbility)Activator.CreateInstance(abilityDef.MainVerb.verbClass);
verb_UseAbility.caster = __instance.Pawn;
verb_UseAbility.Ability = __instance;
verb_UseAbility.verbProps = abilityDef.MainVerb;
verb = verb_UseAbility;
}
if (verb != null)
{
Log.Message("verb is no longer null");
}
job = abilityDef.GetJob(verb.UseAbilityProps.AbilityTargetCategory, target);
job.playerForced = true;
job.verbToUse = verb;
job.count = context == AbilityContext.Player ? 1 : 0; //Count 1 for Player : 0 for AI
if (target != null)
{
if (target.Thing is Pawn pawn2)
{
job.killIncappedTarget = pawn2.Downed;
}
}
__result = job;
return(false);
}
public override void CompTick()
{
base.CompTick();
tickCounter++;
if (tickCounter > Props.psycastFrequency)
{
tickCounter = 0;
if (this.parent is Pawn sourcePawn && sourcePawn != null)
{
bool isAwake = !sourcePawn.Dead && !sourcePawn.Downed && sourcePawn.Map != null && !sourcePawn.stances.stunner.Stunned && sourcePawn.TryGetComp <CompCanBeDormant>().Awake;
if (sourcePawn.psychicEntropy == null)
{
sourcePawn.psychicEntropy = new Pawn_PsychicEntropyTracker(sourcePawn);
}
if (isAwake)
{
string psycastName = Props.psycastsToUse[Rand.Range(0, Props.psycastsToUse.Count)];
foreach (Thing thing in GenRadial.RadialDistinctThingsAround(sourcePawn.Position, sourcePawn.Map, Props.psycastRange, true))
{
if (thing != null && thing is Pawn targetPawn && targetPawn != sourcePawn && targetPawn.health != null)
{
if (targetPawn.RaceProps.IsMechanoid && targetPawn.Faction == Faction.OfMechanoids)
{
AbilityDef psycastDef = DefDatabase <AbilityDef> .GetNamed(psycastName);
Psycast psycast = new Psycast(sourcePawn, psycastDef);
psycast.Activate(targetPawn, sourcePawn);
break;
}
}
}
}
}
}
}
public AbilityDef GetAttributeDef(int index)
{
AbilityDef result = null;
bool flag = this.TMattributeDefs != null && this.TMattributeDefs.Count > 0;
if (flag)
{
result = this.TMattributeDefs[0];
bool flag2 = index > -1 && index < this.TMattributeDefs.Count;
if (flag2)
{
result = this.TMattributeDefs[index];
}
else
{
bool flag3 = index >= this.TMattributeDefs.Count;
if (flag3)
{
result = this.TMattributeDefs[this.TMattributeDefs.Count - 1];
}
}
}
return(result);
}
private static Type GetBestFallbackType <T>(XmlNode node)
{
if (typeof(Thing).IsAssignableFrom(typeof(T)))
{
ThingDef thingDef = TryFindDef <ThingDef>(node, "def");
if (thingDef != null)
{
return(thingDef.thingClass);
}
}
else if (typeof(Hediff).IsAssignableFrom(typeof(T)))
{
HediffDef hediffDef = TryFindDef <HediffDef>(node, "def");
if (hediffDef != null)
{
return(hediffDef.hediffClass);
}
}
else if (typeof(Ability).IsAssignableFrom(typeof(T)))
{
AbilityDef abilityDef = TryFindDef <AbilityDef>(node, "def");
if (abilityDef != null)
{
return(abilityDef.abilityClass);
}
}
else if (typeof(Thought).IsAssignableFrom(typeof(T)))
{
ThoughtDef thoughtDef = TryFindDef <ThoughtDef>(node, "def");
if (thoughtDef != null)
{
return(thoughtDef.thoughtClass);
}
}
return(typeof(T));
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
return pawn.pawn.Dead;
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
return !(pawn.pawn.Dead || pawn.pawn.Downed);
}
