public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
Brain brain = pawn.pawn.GetSquadBrain();
if (brain == null)
return AbilityTarget_ThingInCategory.emptyThings;
return brain.ownedPawns.OfType<Thing>();
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
if (this.optionalSource == null)
return Find.ListerPawns.PawnsInFaction(pawn.pawn.Faction).OfType<Thing>();
else
return this.Filter(ability, pawn);
}
public override void OnSucessfullCast(Saveable_Caster caster, IEnumerable<Thing> targets, IExposable effectState)
{
float exceedPower = this.totalPower;
foreach (Pawn target in targets.OfType<Pawn>())
{
float pawnAvailPower = this.targetPower;
if (pawnAvailPower + exceedPower >= this.treatLocalInjuryPowerUse)
{
foreach (Hediff_Injury toTreat in target.health.hediffSet.GetInjuriesTreatable().OrderByDescending(i => i.Severity))
{
pawnAvailPower -= this.treatLocalInjuryPowerUse;
HediffComp_Tendable hediffComp_Treatable = toTreat.TryGetComp<HediffComp_Tendable>();
if (hediffComp_Treatable == null)
Log.Error("Tried to treat " + toTreat + " which does not have a HediffComp_Tendable");
else
hediffComp_Treatable.CompTreated(0.3f, 1);
Brain brain = caster.pawn.GetSquadBrain();
if ((brain != null) &&
(!target.Downed) &&
(target.GetSquadBrain() == null))
brain.AddPawn(target);
if (pawnAvailPower < 0)
{
exceedPower += pawnAvailPower;
pawnAvailPower = 0;
}
if (pawnAvailPower + exceedPower < this.treatLocalInjuryPowerUse)
break;
}
}
if (pawnAvailPower + exceedPower >= this.healLocalInjuryPowerUse)
{
foreach (Hediff_Injury toHeal in target.health.hediffSet.hediffs.OfType<Hediff_Injury>()
.Where(i => i.IsTendedAndHealing() && (i.Severity != 0.0f))
.OrderByDescending(i => i.Severity))
{
float maximum = ((pawnAvailPower + exceedPower) / this.healLocalInjuryPowerUse);
maximum = Math.Min(maximum, toHeal.Severity);
toHeal.DirectHeal(maximum);
pawnAvailPower -= maximum * this.healLocalInjuryPowerUse;
if (pawnAvailPower < 0)
{
exceedPower += pawnAvailPower;
pawnAvailPower = 0;
}
if (pawnAvailPower + exceedPower < this.healLocalInjuryPowerUse)
break;
}
}
}
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
if (this.target == null)
return ability.target.Targets(ability, pawn).Any();
else
return this.target.Targets(ability, pawn).Any();
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List <Thing> targets, ref IExposable effectState)
{
if (!base.TryStart(ability, caster, ref targets, ref effectState))
{
return(false);
}
if (targets == null)
{
return(false);
}
targets = targets
.OfType <Pawn>()
.Where(i => i.MaxHitPoints > 0)
.Where(i => i.health.summaryHealth.SummaryHealthPercent < this.healthTrashHold)
.Cast <Thing>()
.ToList();
if (targets.Any())
{
return(true);
}
else
{
return(false);
}
}
public override void OnSucessfullCast(Saveable_Caster pawn, IEnumerable <Thing> targets, IExposable effectState)
{
List <Pawn> newPawns = new List <Pawn>();
foreach (PawnKindDef pawnKind in this.pawnKinds)
{
Pawn newPawn = PawnGenerator.GeneratePawn(pawnKind, pawn.pawn.Faction);
IntVec3 loc = CellFinder.RandomClosewalkCellNear(pawn.pawn.Position, this.range);
GenSpawn.Spawn(newPawn, loc);
newPawns.Add(newPawn);
if (this.spawnedMote != null)
{
this.spawnedMote.AbilityStarted(pawn, newPawn);
}
}
Brain brain = pawn.pawn.GetSquadBrain();
if (brain == null)
{
StateGraph squadBrainStateGraph = GraphMaker.AssaultColonyGraph(pawn.pawn.Faction, false, false);
newPawns.Insert(0, pawn.pawn);
BrainMaker.MakeNewBrain(pawn.pawn.Faction, squadBrainStateGraph, newPawns);
}
else
{
foreach (Pawn newPawn in newPawns)
{
brain.AddPawn(newPawn);
}
}
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
if (this.optionalSource == null)
return GenAI.PawnTargetsFor(pawn.pawn.Faction).Cast<Thing>();
else
return this.Filter(ability, pawn);
}
public override void OnSucessfullCast(Saveable_Caster caster, IEnumerable <Thing> targets, IExposable effectState)
{
MapComponent_Ability component = MapComponent_Ability.GetOrCreate();
foreach (Pawn target in targets)
{
AbilityEffect_UtilityChangeKind evolveItem = this.items.First(i => i.from.Contains(target.def));
Brain brain = target.GetSquadBrain();
foreach (PawnKindDef kind in evolveItem.to)
{
Pawn newPawn = AbilityEffect_Revive.Copy(caster.pawn, kind, target.Faction);
GenSpawn.Spawn(newPawn, target.Position);
if (brain != null)
{
brain.AddPawn(newPawn);
}
}
Building building = StoreUtility.StoringBuilding(target);
if (building != null)
{
((Building_Storage)building).Notify_LostThing(target);
}
target.Destroy(DestroyMode.Vanish);
}
}
public IEnumerable <Thing> Filter(AbilityDef ability, Saveable_Caster pawn)
{
foreach (Thing thing in this.optionalSource.Targets(ability, pawn))
{
Pawn thingPawn = thing as Pawn;
if (thingPawn != null)
{
if (thingPawn.Faction == pawn.pawn.Faction)
{
yield return(thing);
}
continue;
}
Corpse corpsePawn = thing as Corpse;
if (corpsePawn != null)
{
if (corpsePawn.innerPawn.Faction == pawn.pawn.Faction)
{
yield return(thing);
}
continue;
}
}
}
internal void ReplacePawnAbility(Saveable_Caster oldSavedPawn, Pawn newPawn)
{
this.pawnCache.Remove(oldSavedPawn);
Saveable_Caster newSavedPawn = this.GetPawnHabilty(newPawn);
foreach (Saveable_ExecutionLog oldLog in oldSavedPawn.executionLogs)
{
bool equals = false;
foreach (Saveable_ExecutionLog newLog in newSavedPawn.executionLogs)
{
if (oldLog.ability == newLog.ability)
{
equals = true;
newLog.numberOfExecution = oldLog.numberOfExecution;
newLog.ticksSinceExecution = oldLog.ticksSinceExecution;
break;
}
}
if (!equals)
{
newSavedPawn.executionLogs.Add(oldLog);
}
}
}
public override void OnSucessfullCast(Saveable_Caster pawn, IEnumerable<Thing> targets, IExposable effectState)
{
List<Pawn> newPawns = new List<Pawn>();
foreach (PawnKindDef pawnKind in this.pawnKinds)
{
Pawn newPawn = PawnGenerator.GeneratePawn(pawnKind, pawn.pawn.Faction);
IntVec3 loc = CellFinder.RandomClosewalkCellNear(pawn.pawn.Position, this.range);
GenSpawn.Spawn(newPawn, loc);
newPawns.Add(newPawn);
if (this.spawnedMote != null)
this.spawnedMote.AbilityStarted(pawn, newPawn);
}
Brain brain = pawn.pawn.GetSquadBrain();
if (brain == null)
{
StateGraph squadBrainStateGraph = GraphMaker.AssaultColonyGraph(pawn.pawn.Faction, false, false);
newPawns.Insert(0, pawn.pawn);
BrainMaker.MakeNewBrain(pawn.pawn.Faction, squadBrainStateGraph, newPawns);
}
else
foreach (Pawn newPawn in newPawns)
brain.AddPawn(newPawn);
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
foreach (Thing thing in this.target.Targets(ability, pawn))
{
Pawn thingPawn = thing as Pawn;
if (thingPawn != null)
{
if (this.races.Contains(thingPawn.def))
{
yield return(thing);
}
continue;
}
Corpse corpsePawn = thing as Corpse;
if (corpsePawn != null)
{
if (this.races.Contains(corpsePawn.innerPawn.def))
{
yield return(thing);
}
continue;
}
}
}
public override float Replenish(Saveable_Caster pawn)
{
if (pawn.pawn.Dead)
return this.ammountDead;
if (pawn.pawn.Downed)
return this.ammountDowned;
return this.ammount;
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
IEnumerable<Thing> things = Find.ListerThings.ThingsMatching(new ThingRequest() { group = this.group });
if (things == null)
return AbilityTarget_ThingInCategory.emptyThings;
else
return things;
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List<Thing> targets, ref IExposable effectState)
{
AbilityEffect_RandomState state = new AbilityEffect_RandomState();
state.item = Rand.Range(0, this.items.Count);
effectState = state;
return this.items[state.item].TryStart(ability, caster, ref targets, ref state.effectState);
}
public JobDriverHolder(AbilityEffect_Cast owner, JobDriver_AbilityEffect jobDriver, Saveable_Caster caster, IEnumerable <Thing> targets, IExposable effectState)
{
this.owner = owner;
this.jobDriver = jobDriver;
this.effectState = effectState;
this.caster = caster;
this.targets = targets;
}
public override void OnSucessfullCast(Saveable_Caster caster, IEnumerable <Thing> targets, IExposable effectState)
{
foreach (Corpse corpse in targets)
{
corpse.def.fillPercent = 0.75f;
Find.CoverGrid.Register(corpse);
}
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List <Thing> targets, ref IExposable effectState)
{
AbilityEffect_RandomState state = new AbilityEffect_RandomState();
state.item = Rand.Range(0, this.items.Count);
effectState = state;
return(this.items[state.item].TryStart(ability, caster, ref targets, ref state.effectState));
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
if (this.items == null)
return false;
foreach (AbilityRequeriment requeriment in this.items)
if (requeriment.Sucess(ability, pawn))
return true;
return false;
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
Brain brain = pawn.pawn.GetSquadBrain();
if (brain == null)
{
return(AbilityTarget_ThingInCategory.emptyThings);
}
return(brain.ownedPawns.OfType <Thing>());
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
Saveable_ExecutionLog log = pawn.GetLog(ability);
int ticks = this.initial + log.numberOfExecution * this.between;
if (this.minimum > 0)
ticks = Math.Max(this.minimum, ticks);
if (this.maximum > 0)
ticks = Math.Min(this.maximum, ticks);
return log.ticksSinceExecution >= ticks;
}
public override bool Visible(Saveable_Caster pawn)
{
if (pawn.pawn.Dead)
return this.ammountDead != 0;
else
if (pawn.pawn.Downed)
return this.ammountDowned != 0;
else
return this.ammount != 0;
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster saveablePawn)
{
float maximumSquared = this.maximumRange * this.maximumRange;
float minimumSquared = this.minimumRange * this.minimumRange;
if (closestFirst)
{
List <KeyValuePair <float, Thing> > ranges = new List <KeyValuePair <float, Thing> >();
foreach (Thing thing in this.target.Targets(ability, saveablePawn))
{
float lengthHorizontalSquared = (saveablePawn.pawn.Position - thing.Position).LengthHorizontalSquared;
if ((maximumSquared > 0) &&
(maximumSquared < lengthHorizontalSquared))
{
continue;
}
if ((minimumSquared > 0) &&
(minimumSquared > lengthHorizontalSquared))
{
continue;
}
ranges.Add(new KeyValuePair <float, Thing>(lengthHorizontalSquared, thing));
}
ranges.Sort((x, y) => x.Key.CompareTo(y.Key));
foreach (KeyValuePair <float, Thing> t in ranges)
{
yield return(t.Value);
}
}
else
{
foreach (Thing thing in this.target.Targets(ability, saveablePawn))
{
float lengthHorizontalSquared = (saveablePawn.pawn.Position - thing.Position).LengthHorizontalSquared;
if ((maximumSquared > 0) &&
(maximumSquared < lengthHorizontalSquared))
{
continue;
}
if ((minimumSquared > 0) &&
(minimumSquared > lengthHorizontalSquared))
{
continue;
}
yield return(thing);
}
}
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
if (this.optionalSource == null)
{
return(Find.ListerPawns.PawnsInFaction(pawn.pawn.Faction).OfType <Thing>());
}
else
{
return(this.Filter(ability, pawn));
}
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
if (this.target == null)
{
return(ability.target.Targets(ability, pawn).Any());
}
else
{
return(this.target.Targets(ability, pawn).Any());
}
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
if (this.optionalSource == null)
{
return(GenAI.PawnTargetsFor(pawn.pawn.Faction).Cast <Thing>());
}
else
{
return(this.Filter(ability, pawn));
}
}
public override float Replenish(Saveable_Caster pawn)
{
if (pawn.pawn.Dead)
{
return(this.ammountDead);
}
if (pawn.pawn.Downed)
{
return(this.ammountDowned);
}
return(this.ammount);
}
public override void AbilityStarted(Saveable_Caster caster, Thing target)
{
Saveable_Mote_Default mote = new Saveable_Mote_Default();
mote.target = target;
mote.currentColor = this.color;
mote.alphaChange = 0.0f;
mote.exactAlpha = 0.5f;
mote.exactPosition = target.DrawPos;
mote.exactScale = new Vector3(1, 1, 1);
caster.AddMote(mote);
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
Brain squad = pawn.pawn.GetSquadBrain();
if (squad == null)
{
return(true);
}
else
{
return(squad.ownedPawns.Sum(i => i.kindDef.combatPower) * this.squadPowerMultiplier < AbilityRequeriment_ColonyBiggerThan.ColonySize());
}
}
private bool TryStartNextAbility(Saveable_Caster value, out AbilityDef ability, out List <Thing> targets, out IExposable effectState)
{
List <KeyValuePair <int, AbilityDef> > priorities = new List <KeyValuePair <int, AbilityDef> >();
foreach (Saveable_ExecutionLog log in value.executionLogs)
{
if ((!log.ability.races.Contains(value.pawn.def)) ||
(log.ability.validity == null) ||
(!log.ability.validity.Sucess(log.ability, value)))
{
log.isValid = false;
continue;
}
log.isValid = true;
if ((log.ability.requeriment != null) &&
(!log.ability.requeriment.Sucess(log.ability, value)))
{
continue;
}
priorities.Add(new KeyValuePair <int, AbilityDef>(log.ability.priority.GetPriority(log.ability, value.pawn), log.ability));
}
if (priorities.Any())
{
priorities.Sort((x, y) => y.Key.CompareTo(x.Key));
foreach (KeyValuePair <int, AbilityDef> itm in priorities)
{
effectState = null;
targets = null;
if (itm.Value.target != null)
{
targets = itm.Value.target.Targets(itm.Value, value).ToList();
}
if (itm.Value.effect.TryStart(itm.Value, value, ref targets, ref effectState))
{
ability = itm.Value;
return(true);
}
}
}
ability = null;
effectState = null;
targets = null;
return(false);
}
public override void Completed(Saveable_Caster caster, bool sucess, Action <Saveable_Mote> terminated)
{
this.terminated = terminated;
this.exactAlpha = 1.0f;
this.alphaChange = -1.0f / 64.0f;
if (sucess)
{
this.currentColor = Color.green;
}
else
{
this.currentColor = Color.red;
}
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List<Thing> target, ref IExposable effectState)
{
if (!base.TryStart(ability, caster, ref target, ref effectState))
return false;
if ((target == null) ||
(this.items == null) ||
(!this.items.Any()))
return false;
target = target.OfType<Pawn>().Where(i => this.items.SelectMany(j => j.from).Contains(i.def)).OfType<Thing>().ToList();
return target.Any();
}
public bool TryGetPawnHability(Pawn pawn, out Saveable_Caster value)
{
foreach (Saveable_Caster caster in this.pawnCache)
{
if (caster.pawn == pawn)
{
value = caster;
return(true);
}
}
value = null;
return(false);
}
public override ThinkResult TryIssueJobPackage(Pawn pawn)
{
Saveable_Caster cachePawn = MapComponent_Ability.GetOrCreate().GetPawnHabilty(pawn);
if (cachePawn.whaitingForThinkNode)
{
cachePawn.whaitingForThinkNode = false;
Saveable_ExecutionLog log = cachePawn.GetLog(cachePawn.currentAbility);
log.numberOfExecution++;
log.ticksSinceExecution = 0;
return(new ThinkResult(new Job(cachePawn.currentAbility.effect.StartJob(cachePawn.effectState)), this));
}
return(ThinkResult.NoJob);
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
if (this.items == null)
{
return(false);
}
foreach (AbilityRequeriment requeriment in this.items)
{
if (!requeriment.Sucess(ability, pawn))
{
return(false);
}
}
return(true);
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
Saveable_ExecutionLog log = pawn.GetLog(ability);
int ticks = this.initial + log.numberOfExecution * this.between;
if (this.minimum > 0)
{
ticks = Math.Max(this.minimum, ticks);
}
if (this.maximum > 0)
{
ticks = Math.Min(this.maximum, ticks);
}
return(log.ticksSinceExecution >= ticks);
}
public void StartCast(Saveable_Caster caster, IEnumerable <Thing> targets)
{
caster.manaValue -= this.manaCost;
if (this.casterMote != null)
{
this.casterMote.AbilityStarted(caster, caster.pawn);
}
if (this.targetMote != null)
{
foreach (Thing target in targets)
{
this.targetMote.AbilityStarted(caster, target);
}
}
}
public override IEnumerable <Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
IEnumerable <Thing> things = Find.ListerThings.ThingsMatching(new ThingRequest()
{
group = this.group
});
if (things == null)
{
return(AbilityTarget_ThingInCategory.emptyThings);
}
else
{
return(things);
}
}
public override bool Visible(Saveable_Caster pawn)
{
if (pawn.pawn.Dead)
{
return(this.ammountDead != 0);
}
else
if (pawn.pawn.Downed)
{
return(this.ammountDowned != 0);
}
else
{
return(this.ammount != 0);
}
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster saveablePawn)
{
float maximumSquared = this.maximumRange * this.maximumRange;
float minimumSquared = this.minimumRange * this.minimumRange;
if (closestFirst)
{
List<KeyValuePair<float, Thing>> ranges = new List<KeyValuePair<float, Thing>>();
foreach (Thing thing in this.target.Targets(ability, saveablePawn))
{
float lengthHorizontalSquared = (saveablePawn.pawn.Position - thing.Position).LengthHorizontalSquared;
if ((maximumSquared > 0) &&
(maximumSquared < lengthHorizontalSquared))
continue;
if ((minimumSquared > 0) &&
(minimumSquared > lengthHorizontalSquared))
continue;
ranges.Add(new KeyValuePair<float, Thing>(lengthHorizontalSquared, thing));
}
ranges.Sort((x, y) => x.Key.CompareTo(y.Key));
foreach (KeyValuePair<float, Thing> t in ranges)
yield return t.Value;
}
else
{
foreach (Thing thing in this.target.Targets(ability, saveablePawn))
{
float lengthHorizontalSquared = (saveablePawn.pawn.Position - thing.Position).LengthHorizontalSquared;
if ((maximumSquared > 0) &&
(maximumSquared < lengthHorizontalSquared))
continue;
if ((minimumSquared > 0) &&
(minimumSquared > lengthHorizontalSquared))
continue;
yield return thing;
}
}
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List <Thing> target, ref IExposable effectState)
{
if (!base.TryStart(ability, caster, ref target, ref effectState))
{
return(false);
}
if ((target == null) ||
(this.items == null) ||
(!this.items.Any()))
{
return(false);
}
target = target.OfType <Pawn>().Where(i => this.items.SelectMany(j => j.from).Contains(i.def)).OfType <Thing>().ToList();
return(target.Any());
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List<Thing> targets, ref IExposable effectState)
{
if (!base.TryStart(ability, caster, ref targets, ref effectState))
return false;
if (targets == null)
return false;
targets = targets
.OfType<Pawn>()
.Where(i => i.MaxHitPoints > 0)
.Where(i => i.health.summaryHealth.SummaryHealthPercent < this.healthTrashHold)
.Cast<Thing>()
.ToList();
if (targets.Any())
return true;
else
return false;
}
public IEnumerable<Thing> Filter(AbilityDef ability, Saveable_Caster pawn)
{
foreach (Thing thing in this.optionalSource.Targets(ability, pawn))
{
Pawn thingPawn = thing as Pawn;
if (thingPawn != null)
{
if (thingPawn.Faction == pawn.pawn.Faction)
yield return thing;
continue;
}
Corpse corpsePawn = thing as Corpse;
if (corpsePawn != null)
{
if (corpsePawn.innerPawn.Faction == pawn.pawn.Faction)
yield return thing;
continue;
}
}
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
foreach (Thing thing in this.target.Targets(ability, pawn))
{
Pawn thingPawn = thing as Pawn;
if (thingPawn != null)
{
if (this.races.Contains(thingPawn.def))
yield return thing;
continue;
}
Corpse corpsePawn = thing as Corpse;
if (corpsePawn != null)
{
if (this.races.Contains(corpsePawn.innerPawn.def))
yield return thing;
continue;
}
}
}
protected override void FillTab()
{
Saveable_Caster pawn = MapComponent_Ability.GetOrCreate().GetPawnHabilty(this.HabilityPawn());
float num = 10;
Rect rect;
Text.Font = GameFont.Small;
if (this.ShowMana(pawn))
{
rect = new Rect(10, num, this.size.x - 20 - 30, 22);
Text.Anchor = TextAnchor.MiddleLeft;
GUI.DrawTexture(rect, BaseContent.BlackTex);
float mana = pawn.manaValue;
GUI.DrawTexture(new Rect(rect.xMin, rect.yMin, rect.width * mana / 100, rect.height), ITab_Pawn_Ability.manaColor);
GUI.Label(new Rect(rect.xMin + 5, rect.yMin, rect.width - 10, rect.height), "AbilityPack.Mana".Translate() + mana.ToString("N1"));
num += 22 + 10;
}
if (this.ShowAbility(pawn))
{
rect = new Rect(10, num, this.size.x - 20, this.size.y - 10 - num);
GUI.color = abilityLabelColor;
Text.Anchor = TextAnchor.LowerLeft;
Widgets.Label(new Rect(15, num, this.size.x - 20, 22f), "AbilityPack.Abilities".Translate());
num += 22;
this.WriteLine(ref num, "AbilityPack.ExecutionNumber".Translate(), "AbilityPack.TicksSinseExecution".Translate(), "AbilityPack.AbilityName".Translate());
foreach (Saveable_ExecutionLog log in pawn.executionLogs.Where(i => i.isValid && i.ability.visible))
{
this.WriteLine(ref num, log.numberOfExecution.ToString(), log.ticksSinceExecution.ToString(), log.ability.label);
}
Text.Anchor = TextAnchor.UpperLeft;
}
}
public override void OnSucessfullCast(Saveable_Caster caster, IEnumerable<Thing> targets, IExposable effectState)
{
MapComponent_Ability component = MapComponent_Ability.GetOrCreate();
foreach (Pawn target in targets)
{
AbilityEffect_UtilityChangeKind evolveItem = this.items.First(i => i.from.Contains(target.def));
Brain brain = target.GetSquadBrain();
foreach (PawnKindDef kind in evolveItem.to)
{
Pawn newPawn = AbilityEffect_Revive.Copy(caster.pawn, kind, target.Faction);
GenSpawn.Spawn(newPawn, target.Position);
if (brain != null)
brain.AddPawn(newPawn);
}
Building building = StoreUtility.StoringBuilding(target);
if (building != null)
((Building_Storage)building).Notify_LostThing(target);
target.Destroy(DestroyMode.Vanish);
}
}
public Saveable_Caster GetPawnHabilty(Pawn pawn)
{
Saveable_Caster value;
if (!this.TryGetPawnHability(pawn, out value))
{
if (this.manaCache == null)
{
this.manaCache = new Dictionary <ThingDef, ManaDef>();
foreach (ManaDef ability in DefDatabase <ManaDef> .AllDefs)
{
foreach (ThingDef race in ability.races)
{
this.manaCache.Add(race, ability);
}
}
}
value = new Saveable_Caster();
value.pawn = pawn;
this.pawnCache.Add(value);
this.InjectTab(pawn.def);
if (this.manaCache.TryGetValue(pawn.def, out value.manaDef))
{
value.manaValue = value.manaDef.initial;
}
foreach (AbilityDef ability in this.GetAllowedAbilities(value.pawn))
{
value.GetLog(ability);
}
}
return(value);
}
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;
}
private void NormalTick(Saveable_Caster value)
{
Pawn pawn = value.pawn;
if (value.manaDef != null)
{
value.manaValue += value.manaDef.replenish.Replenish(value);
value.manaValue = Mathf.Clamp(value.manaValue, 0, 100);
}
AbilityDef executingAbility;
if ((pawn.CurJob != null) &&
((pawn.CurJob.def.defName == "AbilityEffect_JobDef") ||
(pawn.CurJob.def.defName == "AbilityEffect_JobDef_Interruptable")))
{
executingAbility = value.currentAbility;
}
else
{
executingAbility = null;
}
foreach (Saveable_ExecutionLog log in value.executionLogs)
{
if (log.ability == executingAbility)
{
log.ticksSinceExecution = 0;
}
else
if (log.isValid)
{
log.ticksSinceExecution++;
}
}
}
private bool ShowMana(Saveable_Caster saveable)
{
return (saveable.manaDef != null) &&
(saveable.manaDef.replenish.Visible(saveable));
}
public abstract float Replenish(Saveable_Caster pawn);
public override void ExecuteWhileIncapacitated(Saveable_Caster caster, IEnumerable<Thing> targets, IExposable effectState)
{
AbilityEffect_RandomState typedState = (AbilityEffect_RandomState)effectState;
this.items[typedState.item].ExecuteWhileIncapacitated(caster, targets, typedState.effectState);
}
public override bool Sucess(AbilityDef ability, Saveable_Caster pawn)
{
return pawn.manaValue <= this.value;
}
public override IEnumerable<Thing> Targets(AbilityDef ability, Saveable_Caster pawn)
{
return this.target.Targets(ability, pawn).Take(this.count);
}
public override bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List<Thing> targets, ref IExposable effectState)
{
if (!base.TryStart(ability, caster, ref targets, ref effectState))
return false;
if (targets == null)
return false;
List<Thing> corpses = AbilityEffect_Revive.SelectCorpses(targets);
if (corpses.Any())
{
targets = corpses;
return true;
}
else
return false;
}
public override void OnSucessfullCast(Saveable_Caster caster, IEnumerable<Thing> targets, IExposable effectState)
{
MapComponent_Ability component = MapComponent_Ability.GetOrCreate();
Brain brain = caster.pawn.GetSquadBrain();
foreach (Corpse corpse in targets)
{
List<PawnKindDef> newKinds = new List<PawnKindDef>();
if (this.changes != null)
{
AbilityEffect_UtilityChangeKind kind = this.changes.FirstOrDefault(i => i.from.Contains(corpse.innerPawn.def));
if (kind != null)
newKinds.AddRange(kind.to);
else
newKinds.Add(corpse.innerPawn.kindDef);
}
else
newKinds.Add(corpse.innerPawn.kindDef);
foreach (PawnKindDef kindDef in newKinds)
{
Pawn newPawn = AbilityEffect_Revive.Copy(caster.pawn, kindDef, this.changeFaction ? caster.pawn.Faction : corpse.innerPawn.Faction);
if (corpse.innerPawn == caster.pawn)
component.ReplacePawnAbility(caster, newPawn);
IntVec3 position = corpse.Position;
GenSpawn.Spawn(newPawn, position);
if ((newPawn.Faction == caster.pawn.Faction) &&
(brain != null))
brain.AddPawn(newPawn);
}
Building building = StoreUtility.StoringBuilding(corpse);
if (building != null)
((Building_Storage)building).Notify_LostThing(corpse);
corpse.Destroy(DestroyMode.Vanish);
//if (this.healUntil > 0)
//{
// HediffSet hediffSet = newPawn.healthTracker.hediffSet;
// while ((newPawn.healthTracker.summaryHealth.SummaryHealthPercent >= this.healUntil) &&
// (AbilityEffect_Revive.HittablePartsViolence(hediffSet).Any<BodyPartRecord>()))
// {
// BodyPartRecord bodyPartRecord = AbilityEffect_Revive.HittablePartsViolence(hediffSet).RandomElementByWeight((BodyPartRecord x) => x.absoluteFleshCoverage);
// int amount = Rand.RangeInclusive(8, 25);
// DamageDef def;
// if (bodyPartRecord.depth == BodyPartDepth.Outside)
// def = HealthUtility.RandomViolenceDamageType();
// else
// def = DamageDefOf.Blunt;
// DamageInfo dinfo = new DamageInfo(def, amount, null, new BodyPartDamageInfo?(new BodyPartDamageInfo(bodyPartRecord, false, (List<HediffDef>)null)), null);
// newPawn.TakeDamage(dinfo);
// }
//}
}
}
public override IEnumerable<Toil> MakeNewToils(JobDriver_AbilityEffect jobDriver, Saveable_Caster caster, IEnumerable<Thing> targets, IExposable effectState)
{
AbilityEffect_RandomState typedState = (AbilityEffect_RandomState)effectState;
return this.items[typedState.item].MakeNewToils(jobDriver, caster, targets, typedState.effectState);
}
public abstract bool TryStart(AbilityDef ability, Saveable_Caster caster, ref List<Thing> targets, ref IExposable effectState);
public abstract bool Visible(Saveable_Caster pawn);
private bool ShowAbility(Saveable_Caster saveable)
{
return saveable.executionLogs.Where(i => i.isValid && i.ability.visible).Any();
}
