protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, ref DamageWorker.DamageResult result)
{
base.FinalizeAndAddInjury(pawn, totalDamage, dinfo, ref result);
}
// Token: 0x06004B8B RID: 19339 RVA: 0x00234924 File Offset: 0x00232D24
private void CheckDuplicateDamageToOuterParts(DamageInfo dinfo, Pawn pawn, float totalDamage, DamageWorker.DamageResult result)
{
if (!dinfo.AllowDamagePropagation)
{
return;
}
if (dinfo.Def.harmAllLayersUntilOutside && dinfo.HitPart.depth == BodyPartDepth.Inside)
{
BodyPartRecord parent = dinfo.HitPart.parent;
do
{
if (pawn.health.hediffSet.GetPartHealth(parent) != 0f && parent.coverageAbs > 0f)
{
HediffDef hediffDefFromDamage = HealthUtility.GetHediffDefFromDamage(dinfo.Def, pawn, parent);
Hediff_Injury hediff_Injury = (Hediff_Injury)HediffMaker.MakeHediff(hediffDefFromDamage, pawn, null);
hediff_Injury.Part = parent;
hediff_Injury.source = dinfo.Weapon;
hediff_Injury.sourceBodyPartGroup = dinfo.WeaponBodyPartGroup;
hediff_Injury.Severity = totalDamage;
if (hediff_Injury.Severity <= 0f)
{
hediff_Injury.Severity = 1f;
}
this.FinalizeAndAddInjury(pawn, hediff_Injury, dinfo, result);
}
if (parent.depth == BodyPartDepth.Outside)
{
break;
}
parent = parent.parent;
}while (parent != null);
}
}
protected override bool TryCastShot()
{
// power affects enumerator
DamageWorker.DamageResult result = DamageWorker.DamageResult.MakeNew();
Pawn caster = this.CasterPawn;
CompAbilityUserMagic comp = caster.GetComp <CompAbilityUserMagic>();
MagicPowerSkill pwr = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_AdvancedHeal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_AdvancedHeal_pwr");
MagicPowerSkill ver = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_AdvancedHeal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_AdvancedHeal_ver");
Pawn pawn = (Pawn)this.currentTarget;
bool flag = pawn != null && !pawn.Dead;
if (flag)
{
int num = 3 + ver.level;
using (IEnumerator <BodyPartRecord> enumerator = pawn.health.hediffSet.GetInjuredParts().GetEnumerator())
{
while (enumerator.MoveNext())
{
BodyPartRecord rec = enumerator.Current;
bool flag2 = num > 0;
if (flag2)
{
int num2 = 1 + ver.level;
ModOptions.SettingsRef settingsRef = new ModOptions.SettingsRef();
if (!this.CasterPawn.IsColonistPlayerControlled && settingsRef.AIHardMode)
{
num2 = 5;
}
IEnumerable <Hediff_Injury> arg_BB_0 = pawn.health.hediffSet.GetHediffs <Hediff_Injury>();
Func <Hediff_Injury, bool> arg_BB_1;
arg_BB_1 = ((Hediff_Injury injury) => injury.Part == rec);
foreach (Hediff_Injury current in arg_BB_0.Where(arg_BB_1))
{
bool flag4 = num2 > 0;
if (flag4)
{
bool flag5 = current.CanHealNaturally() && !current.IsOld();
if (flag5)
{
//current.Heal((float)((int)current.Severity + 1));
if (!this.CasterPawn.IsColonistPlayerControlled)
{
current.Heal(30.0f + (float)pwr.level * 3f); // power affects how much to heal
}
else
{
current.Heal(8.0f + (float)pwr.level * 5f); // power affects how much to heal
}
TM_MoteMaker.ThrowRegenMote(pawn.Position.ToVector3Shifted(), pawn.Map, 1f + .2f * pwr.level);
TM_MoteMaker.ThrowRegenMote(pawn.Position.ToVector3Shifted(), pawn.Map, .8f + .1f * pwr.level);
num--;
num2--;
}
}
}
}
}
}
}
return(true);
}
// Token: 0x06004B88 RID: 19336 RVA: 0x0023478F File Offset: 0x00232B8F
protected virtual void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
totalDamage = this.ReduceDamageToPreserveOutsideParts(totalDamage, dinfo, pawn);
this.FinalizeAndAddInjury(pawn, totalDamage, dinfo, result);
this.CheckDuplicateDamageToOuterParts(dinfo, pawn, totalDamage, result);
}
// Token: 0x06004B84 RID: 19332 RVA: 0x002341E4 File Offset: 0x002325E4
private DamageWorker.DamageResult ApplyToPawn(DamageInfo dinfo, Pawn pawn)
{
DamageWorker.DamageResult damageResult = new DamageWorker.DamageResult();
if (dinfo.Amount <= 0f)
{
return(damageResult);
}
if (!DebugSettings.enablePlayerDamage && pawn.Faction == Faction.OfPlayer)
{
return(damageResult);
}
Map mapHeld = pawn.MapHeld;
bool spawnedOrAnyParentSpawned = pawn.SpawnedOrAnyParentSpawned;
if (dinfo.AllowDamagePropagation && dinfo.Amount >= (float)dinfo.Def.minDamageToFragment)
{
int num = Rand.RangeInclusive(2, 4);
for (int i = 0; i < num; i++)
{
DamageInfo dinfo2 = dinfo;
dinfo2.SetAmount(dinfo.Amount / (float)num);
this.ApplyDamageToPart(dinfo2, pawn, damageResult);
}
}
else
{
this.ApplyDamageToPart(dinfo, pawn, damageResult);
this.ApplySmallPawnDamagePropagation(dinfo, pawn, damageResult);
}
if (damageResult.wounded)
{
DamageWorker_CombiPin.PlayWoundedVoiceSound(dinfo, pawn);
pawn.Drawer.Notify_DamageApplied(dinfo);
}
if (damageResult.headshot && pawn.Spawned)
{
MoteMaker.ThrowText(new Vector3((float)pawn.Position.x + 1f, (float)pawn.Position.y, (float)pawn.Position.z + 1f), pawn.Map, "Headshot".Translate(), Color.white, -1f);
if (dinfo.Instigator != null)
{
if (dinfo.Instigator is Pawn pawn2)
{
pawn2.records.Increment(RecordDefOf.Headshots);
}
}
}
if ((damageResult.deflected || damageResult.diminished) && spawnedOrAnyParentSpawned)
{
EffecterDef effecterDef;
if (damageResult.deflected)
{
if (damageResult.deflectedByMetalArmor && dinfo.Def.canUseDeflectMetalEffect)
{
if (dinfo.Def == DamageDefOf.Bullet)
{
effecterDef = EffecterDefOf.Deflect_Metal_Bullet;
}
else
{
effecterDef = EffecterDefOf.Deflect_Metal;
}
}
else if (dinfo.Def == DamageDefOf.Bullet)
{
effecterDef = EffecterDefOf.Deflect_General_Bullet;
}
else
{
effecterDef = EffecterDefOf.Deflect_General;
}
}
else if (damageResult.diminishedByMetalArmor)
{
effecterDef = EffecterDefOf.DamageDiminished_Metal;
}
else
{
effecterDef = EffecterDefOf.DamageDiminished_General;
}
if (pawn.health.deflectionEffecter == null || pawn.health.deflectionEffecter.def != effecterDef)
{
if (pawn.health.deflectionEffecter != null)
{
pawn.health.deflectionEffecter.Cleanup();
pawn.health.deflectionEffecter = null;
}
pawn.health.deflectionEffecter = effecterDef.Spawn();
}
pawn.health.deflectionEffecter.Trigger(pawn, dinfo.Instigator ?? pawn);
if (damageResult.deflected)
{
pawn.Drawer.Notify_DamageDeflected(dinfo);
}
}
if (!damageResult.deflected && spawnedOrAnyParentSpawned)
{
ImpactSoundUtility.PlayImpactSound(pawn, dinfo.Def.impactSoundType, mapHeld);
}
return(damageResult);
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
if (pawn.RaceProps.Animal)
{
pawn.TakeDamage(new DamageInfo(DamageDefOf.Cut, 20, 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
if (dinfo.HitPart.def.bleedRate > 0)
{
HediffSet hediffSet = pawn.health.hediffSet;
HealthUtility.AdjustSeverity(pawn, pawn.health.hediffSet.hediffs.Last().def, hediffSet.BleedRateTotal * 0.01f);
}
}
}
// Token: 0x06003975 RID: 14709 RVA: 0x001B3F40 File Offset: 0x001B2340
protected override DamageWorker.DamageResult ApplyMeleeDamageToTarget(LocalTargetInfo target)
{
string logmsg = string.Format("");
bool Logging = Def.Logging;
logmsg = string.Format("Target Catergory: {0}", base.currentTarget.Thing.def.category);
if (Logging == true)
{
Log.Message(logmsg);
}
logmsg = string.Format("trying dinfo's");
if (Logging == true)
{
Log.Message(logmsg);
}
DamageWorker.DamageResult result = new DamageWorker.DamageResult();
if (base.currentTarget.Thing.def.category == ThingCategory.Pawn)
{
if (target.IsValid)
{
foreach (DamageInfo dinfo in this.DamageInfosToApply(target))
{
logmsg = string.Format("trying DamageInfo dinfo {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
logmsg = string.Format("trying {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
if (Def.forceWeaponEffectActive == true)
{
Map map = CasterPawn.Map;
IntVec3 position = target.Cell;
Map map2 = map;
float explosionRadius = Def.blastRadius;
DamageDef damageDef = Def.blastdamageDef;
Thing launcher = base.EquipmentSource;
int damageAmount = Def.blastdamageAmount;
float hitdmg = damageAmount;
float armorPenetration = Def.blastarmorPenetration;
SoundDef soundExplode = Def.blastsoundExplode;
ThingDef equipmentDef = base.EquipmentSource.def;
Thing thing = target.Thing;
GenExplosion.DoExplosion(position, map2, explosionRadius, damageDef, launcher, damageAmount, armorPenetration, soundExplode, equipmentDef, null, thing, null, 0f, 0, false, null, 0, 0, 0, false);
DamageInfo daminfo = new DamageInfo(damageDef, hitdmg, armorPenetration, -1f, launcher, null, equipmentDef, DamageInfo.SourceCategory.ThingOrUnknown, thing);
thing.TakeDamage(daminfo);//.AssociateWithLog(battleLogEntry_MeleeCombat);
float KillChance = Def.KillChance;
if (KillChance != 0)
{
float KillRoll = Rand.Range(0, 100);
logmsg = string.Format("rolled {0} needs less than {1} to detonate", KillRoll, KillChance);
if (Logging == true)
{
Log.Message(logmsg);
}
if (KillRoll < KillChance)
{
string msg = string.Format("{0} was slain by a force strike", target.Thing.LabelCap);
target.Thing.Kill(Def.mainDinfo);
if (target.Thing.Faction == Faction.OfPlayer)
{
Messages.Message(msg, MessageTypeDefOf.PawnDeath);
}
}
}
}
if (target.ThingDestroyed || !target.IsValid)
{
break;
}
result = target.Thing.TakeDamage(dinfo);
logmsg = string.Format("trying DamageInfo dinfo 2 {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
}
}
return(result);
}
else
{
foreach (DamageInfo dinfo in this.DamageInfosToApplyOriginal(target))
{
logmsg = string.Format("trying DamageInfo dinfo {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
logmsg = string.Format("trying {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
if (Def.forceWeaponEffectActive == true)
{
Map map = CasterPawn.Map;
IntVec3 position = target.Cell;
Map map2 = map;
float explosionRadius = Def.blastRadius;
DamageDef damageDef = Def.blastdamageDef;
Thing launcher = base.EquipmentSource;
int damageAmount = Def.blastdamageAmount;
float hitdmg = damageAmount;
float armorPenetration = Def.blastarmorPenetration;
SoundDef soundExplode = Def.blastsoundExplode;
ThingDef equipmentDef = base.EquipmentSource.def;
Thing thing = target.Thing;
GenExplosion.DoExplosion(position, map2, explosionRadius, damageDef, launcher, damageAmount, armorPenetration, soundExplode, equipmentDef, null, thing, null, 0f, 0, false, null, 0, 0, 0, false);
DamageInfo daminfo = new DamageInfo(damageDef, hitdmg, armorPenetration, -1f, launcher, null, equipmentDef, DamageInfo.SourceCategory.ThingOrUnknown, thing);
thing.TakeDamage(daminfo);//.AssociateWithLog(battleLogEntry_MeleeCombat);
float KillChance = Def.KillChance;
float KillRoll = Rand.Range(0, 100);
logmsg = string.Format("rolled {0} needs less than {1} to detonate", KillRoll, KillChance);
if (Logging == true)
{
Log.Message(logmsg);
}
if (KillRoll < KillChance && KillChance != 0)
{
string msg = string.Format("{0} was slain by a force strike", target.Thing.LabelCap);
target.Thing.Kill(Def.mainDinfo);
if (target.Thing.Faction == Faction.OfPlayer)
{
Messages.Message(msg, MessageTypeDefOf.PawnDeath);
}
}
}
if (target.ThingDestroyed)
{
break;
}
result = target.Thing.TakeDamage(dinfo);
logmsg = string.Format("trying DamageInfo dinfo 2 {0}", dinfo);
if (Logging == true)
{
Log.Message(logmsg);
}
}
return(result);
}
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
Random random = new Random();
if (random.NextDouble() > ((float)(100 - dinfo.Instigator.TryGetComp <CompInfecter>().GetChance) / 100))
{
pawn.health.AddHediff(HediffDefOf.WoundInfection, dinfo.HitPart, null, null);
}
}
// Token: 0x06000006 RID: 6 RVA: 0x000020C4 File Offset: 0x000002C4
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
Map mapHeld = pawn.MapHeld;
DamageDefExtension damageDefExtension = dinfo.Def.GetModExtension <DamageDefExtension>() ?? DamageDefExtension.defaultValues;
int num = GenMath.RoundRandom(totalDamage * damageDefExtension.knockbackDistancePerDamageDealt * (damageDefExtension.scaleKnockbackWithBodySize ? (1f / pawn.BodySize) : 1f));
IntVec3 b = CyberneticWarfareUtility.IntVec3FromDirection8Way(CyberneticWarfareUtility.Direction8WayFromAngle((pawn.PositionHeld - dinfo.Instigator.PositionHeld).AngleFlat));
bool flag = num > 0;
if (flag)
{
float num2 = (float)damageDefExtension.stunDuration;
for (int i = 0; i < num; i++)
{
IntVec3 c = pawn.PositionHeld + b;
bool flag2 = !c.InBounds(mapHeld);
if (flag2)
{
break;
}
bool flag3 = c.Impassable(mapHeld);
if (flag3)
{
num2 *= damageDefExtension.hitBuildingStunDurationFactor;
break;
}
IThingHolder parentHolder = pawn.ParentHolder;
Corpse corpse = parentHolder as Corpse;
bool flag4 = corpse != null;
if (flag4)
{
corpse.Position += b;
}
pawn.Position += b;
}
bool flag5 = !pawn.Dead;
if (flag5)
{
pawn.Notify_Teleported(true, false);
}
bool flag6 = num2 > 0f && pawn.stances != null;
if (flag6)
{
pawn.stances.stunner.StunFor(GenMath.RoundRandom(num2), dinfo.Instigator);
}
}
}
private static bool Prefix(Pawn_HealthTracker __instance, Pawn ___pawn, Hediff hediff, BodyPartRecord part = null, DamageInfo?dinfo = null, DamageWorker.DamageResult result = null)
{
if (hediff.def == HediffDefOf.Scaria || hediff.def == HediffDefOf.Carcinoma)
{
foreach (var oldHediff in ___pawn.health.hediffSet.hediffs)
{
if (oldHediff.def == HML_DefOf.HRM_EpzizymeAlclotoinBooster)
{
return(false);
}
}
}
return(true);
}
public void applyHediffToPawnsInArea(Map map, HashSet <IntVec3> AoE, HediffDef hediff, BodyPartRecord bodyPartRecord, DamageInfo?dinfo = null, DamageWorker.DamageResult damageResult = null)
{
foreach (Pawn pawn in map.listerThings.AllThings.FindAll(c => c is Pawn && AoE.Contains(c.Position)))
{
if (pawn != null && hediff != null)
{
Log.Message(hediff.defName + " , " + pawn.ThingID);
Hediff h = HediffMaker.MakeHediff(hediff, pawn, null);
pawn.health.AddHediff(h, bodyPartRecord, dinfo, damageResult);
}
}
}
public static void DamageInfosToApply_ForceWeapon_Postfix(ref Verb_MeleeAttackDamage __instance, LocalTargetInfo target, ref IEnumerable <DamageInfo> __result)
{
if (__instance != null)
{
if (target == null)
{
return;
}
if (!target.HasThing)
{
return;
}
if (target.Pawn == null)
{
return;
}
if (__instance.CasterIsPawn)
{
Pawn Attacker = __instance.CasterPawn;
Pawn hitPawn = target.Pawn;
if (__instance.CasterPawn.isXenomorph())
{
if (Attacker.def == XenomorphRacesDefOf.RRY_Xenomorph_FaceHugger)
{
if (!hitPawn.isPotentialHost() || Head(hitPawn) == null)
{
return;
}
DamageWorker.DamageResult result = new DamageWorker.DamageResult();
DamageDef def = __instance.verbProps.meleeDamageDef;
float tgtmelee = 0f;
float tgtdodge = 0f;
float armour = 0f;
if (hitPawn.RaceProps.Humanlike)
{
tgtmelee = hitPawn.skills.GetSkill(SkillDefOf.Melee).Level;
}
if (hitPawn.RaceProps.Humanlike)
{
tgtdodge = hitPawn.GetStatValue(StatDefOf.MeleeDodgeChance);
}
if (hitPawn.RaceProps.Humanlike)
{
if (hitPawn.apparel.WornApparel.Count > 0 && hitPawn.apparel.WornApparel is List <Apparel> wornApparel)
{
for (int i = 0; i < wornApparel.Count; i++)
{
bool flag2 = wornApparel[i].def.apparel.CoversBodyPart(Head(hitPawn)) || wornApparel[i].def.apparel.bodyPartGroups.Contains(BodyPartGroupDefOf.FullHead);
if (flag2)
{
armour += wornApparel[i].def.statBases.GetStatOffsetFromList(def.armorCategory.armorRatingStat);
}
}
}
}
float InfectionDefence = 50 + tgtmelee + (armour * 10);
float InfecterRoll = (Rand.Value * 100) * (1 - tgtdodge);
if ((InfecterRoll > InfectionDefence || (hitPawn.Downed || !hitPawn.Awake())) && !hitPawn.health.hediffSet.HasHediff(XenomorphDefOf.RRY_Hediff_Anesthetic))
{
Hediff hediff = HediffMaker.MakeHediff(XenomorphDefOf.RRY_FaceHuggerInfection, hitPawn, null);
Comp_Facehugger _Facehugger = Attacker.TryGetComp <Comp_Facehugger>();
HediffComp_XenoFacehugger comp = hediff.TryGetComp <HediffComp_XenoFacehugger>();
comp.instigator = Attacker;
comp.instigatorKindDef = Attacker.kindDef;
comp.royaleHugger = _Facehugger.RoyaleHugger;
comp.previousImpregnations = _Facehugger.Impregnations;
hitPawn.health.AddHediff(hediff, Head(hitPawn), null);
string text = TranslatorFormattedStringExtensions.Translate("Xeno_Facehugger_Attach", hitPawn.LabelShort, Head(hitPawn).LabelShortCap);
MoteMaker.ThrowText(hitPawn.Position.ToVector3(), hitPawn.Map, text, 5f);
if (Attacker.Spawned)
{
Attacker.DeSpawn();
}
comp.TryAcceptThing(Attacker);
// comp.GetDirectlyHeldThings().TryAdd(CasterPawn);
}
}
else
{
if (!hitPawn.isPotentialHost() || hitPawn.Awake())
{
return;
}
HealthUtility.DamageUntilDowned(hitPawn, false);
}
}
}
}
}
protected override bool TryCastShot()
{
Pawn casterPawn = CasterPawn;
if (!casterPawn.Spawned)
{
return(false);
}
if (casterPawn.stances.FullBodyBusy)
{
return(false);
}
Thing thing = currentTarget.Thing;
if (!CanHitTarget(thing))
{
Log.Warning(string.Concat(casterPawn, " meleed ", thing, " from out of melee position."));
}
casterPawn.rotationTracker.Face(thing.DrawPos);
if (!IsTargetImmobile(currentTarget) && casterPawn.skills != null)
{
casterPawn.skills.Learn(SkillDefOf.Melee, 200f * verbProps.AdjustedFullCycleTime(this, casterPawn));
}
Pawn pawn = thing as Pawn;
if (pawn != null && !pawn.Dead && (casterPawn.MentalStateDef != MentalStateDefOf.SocialFighting || pawn.MentalStateDef != MentalStateDefOf.SocialFighting))
{
pawn.mindState.meleeThreat = casterPawn;
pawn.mindState.lastMeleeThreatHarmTick = Find.TickManager.TicksGame;
}
Map map = thing.Map;
Vector3 drawPos = thing.DrawPos;
SoundDef soundDef;
bool result;
if (Rand.Chance(GetNonMissChance(thing)))
{
if (!Rand.Chance(GetDodgeChance(thing)))
{
soundDef = ((thing.def.category != ThingCategory.Building) ? SoundHitPawn() : SoundHitBuilding());
if (verbProps.impactMote != null)
{
MoteMaker.MakeStaticMote(drawPos, map, verbProps.impactMote);
}
BattleLogEntry_MeleeCombat battleLogEntry_MeleeCombat = CreateCombatLog((ManeuverDef maneuver) => maneuver.combatLogRulesHit, alwaysShow: true);
result = true;
DamageWorker.DamageResult damageResult = ApplyMeleeDamageToTarget(currentTarget);
if (damageResult.stunned && damageResult.parts.NullOrEmpty())
{
Find.BattleLog.RemoveEntry(battleLogEntry_MeleeCombat);
}
else
{
damageResult.AssociateWithLog(battleLogEntry_MeleeCombat);
if (damageResult.deflected)
{
battleLogEntry_MeleeCombat.RuleDef = maneuver.combatLogRulesDeflect;
battleLogEntry_MeleeCombat.alwaysShowInCompact = false;
}
}
}
else
{
result = false;
soundDef = SoundDodge(thing);
MoteMaker.ThrowText(drawPos, map, "TextMote_Dodge".Translate(), 1.9f);
CreateCombatLog((ManeuverDef maneuver) => maneuver.combatLogRulesDodge, alwaysShow: false);
}
}
else
{
result = false;
soundDef = SoundMiss();
CreateCombatLog((ManeuverDef maneuver) => maneuver.combatLogRulesMiss, alwaysShow: false);
}
soundDef.PlayOneShot(new TargetInfo(thing.Position, map));
if (casterPawn.Spawned)
{
casterPawn.Drawer.Notify_MeleeAttackOn(thing);
}
if (pawn != null && !pawn.Dead && pawn.Spawned)
{
pawn.stances.StaggerFor(95);
}
if (casterPawn.Spawned)
{
casterPawn.rotationTracker.FaceCell(thing.Position);
}
if (casterPawn.caller != null)
{
casterPawn.caller.Notify_DidMeleeAttack();
}
return(result);
}
public static bool AddDirect(HediffSet __instance, Hediff hediff, DamageInfo?dinfo = null, DamageWorker.DamageResult damageResult = null)
{
if (hediff.def == null)
{
Log.Error("Tried to add health diff with null def. Canceling.");
return(false);
}
if (hediff.Part != null && !__instance.GetNotMissingParts().Contains(hediff.Part))
{
Log.Error("Tried to add health diff to missing part " + hediff.Part);
return(false);
}
hediff.ageTicks = 0;
hediff.pawn = __instance.pawn;
bool flag = false;
for (int i = 0; i < __instance.hediffs.Count; i++)
{
if (__instance.hediffs[i].TryMergeWith(hediff))
{
flag = true;
}
}
if (!flag)
{
lock (__instance)
{
//List<Hediff> newHediffs = new List<Hediff>(__instance.hediffs) { hediff };
//__instance.hediffs = newHediffs;
__instance.hediffs.Add(hediff);
}
hediff.PostAdd(dinfo);
if (__instance.pawn.needs != null && __instance.pawn.needs.mood != null)
{
__instance.pawn.needs.mood.thoughts.situational.Notify_SituationalThoughtsDirty();
}
}
bool flag2 = hediff is Hediff_MissingPart;
if (!(hediff is Hediff_MissingPart) && hediff.Part != null && hediff.Part != __instance.pawn.RaceProps.body.corePart && __instance.GetPartHealth(hediff.Part) == 0f && hediff.Part != __instance.pawn.RaceProps.body.corePart)
{
bool flag3 = __instance.HasDirectlyAddedPartFor(hediff.Part);
Hediff_MissingPart hediff_MissingPart = (Hediff_MissingPart)HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, __instance.pawn);
hediff_MissingPart.IsFresh = !flag3;
hediff_MissingPart.lastInjury = hediff.def;
__instance.pawn.health.AddHediff(hediff_MissingPart, hediff.Part, dinfo);
damageResult?.AddHediff(hediff_MissingPart);
if (flag3)
{
if (dinfo.HasValue)
{
hediff_MissingPart.lastInjury = HealthUtility.GetHediffDefFromDamage(dinfo.Value.Def, __instance.pawn, hediff.Part);
}
else
{
hediff_MissingPart.lastInjury = null;
}
}
flag2 = true;
}
__instance.DirtyCache();
if (flag2 && __instance.pawn.apparel != null)
{
__instance.pawn.apparel.Notify_LostBodyPart();
}
if (hediff.def.causesNeed != null && !__instance.pawn.Dead)
{
__instance.pawn.needs.AddOrRemoveNeedsAsAppropriate();
}
return(false);
}
/// <summary>
/// Event whenever a Hediff gets added to a pawn
/// </summary>
/// <param name="dinfo"></param>
public static void HediffAdded(Hediff hediff, BodyPartRecord part = null, DamageInfo?dinfo = null, DamageWorker.DamageResult result = null)
{
foreach (var card in AchievementPointManager.GetCards <HediffTracker>())
{
try
{
if ((card.tracker as HediffTracker).Trigger(hediff))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
if (Rand.Chance(chance))
{
pawn.TakeDamage(dinfo);
}
}
//public class DamageWorker_AddInjury : DamageWorker
public static void WerewolfDmgFixFinalizeAndAddInjury(DamageWorker_AddInjury __instance, Pawn pawn, ref Hediff_Injury injury, ref DamageInfo dinfo, ref DamageWorker.DamageResult result)
{
if (dinfo.Amount > 0 && pawn.TryGetComp <CompWerewolf>() is CompWerewolf ww && ww.IsWerewolf && ww.CurrentWerewolfForm != null)
{
if (dinfo.Instigator is Pawn a && ShouldModifyDamage(a))
{
if (a?.equipment?.Primary is ThingWithComps b && !b.IsSilverTreated())
{
int math = (int)(dinfo.Amount) - (int)(dinfo.Amount * (ww.CurrentWerewolfForm.DmgImmunity)); //10% damage. Decimated damage.
dinfo.SetAmount(math);
injury.Severity = math;
//Log.Message(dinfo.Amount.ToString());
}
}
}
}
public static void FinalizeAndAddInjuryPostfix(DamageWorker_AddInjury __instance, Pawn pawn, Hediff_Injury injury, DamageInfo dinfo, DamageWorker.DamageResult result)
{
if (pawn != null)
{
if (injury != null)
{
Comp_NecronOG _Necron = pawn.TryGetCompFast <Comp_NecronOG>();
if (_Necron != null)
{
DamageInfo dInfo = dinfo;
DamageDef damageDef = dinfo.Def;
float AP = dinfo.ArmorPenetrationInt;
float AV = (pawn.kindDef.race.statBases.GetStatValueFromList(dinfo.Def.armorCategory.armorRatingStat, 0f));
bool healable = AP < AV;
if (healable)
{
_Necron.healableHediffs.Add(injury);
}
else
{
_Necron.unhealableHediffs.Add(injury);
}
// Log.Message(string.Format("{1} got a {2} AP: {7} on its {3} AV:{6}, healable: {0}, total Healable: {5}, Unhealable: {4}", healable, pawn.Label, injury.Label, injury.Part, _Necron.unhealableHediffs.Count, _Necron.healableHediffs.Count, AV, AP));
}
}
}
}
protected override DamageWorker.DamageResult ApplyMeleeDamageToTarget(LocalTargetInfo target)
{
DamageWorker.DamageResult result = base.ApplyMeleeDamageToTarget(target);
Pawn targetPawn = this.currentTarget.Thing as Pawn;
if ((targetPawn != null) &&
(!targetPawn.Dead) &&
(!targetPawn.Downed))
{
ThingDef_PowerFist repelProperties = this.EquipmentSource.def as ThingDef_PowerFist;
if (repelProperties == null)
{
Log.Warning("MiningCo. PowerFist: cannot cast EquipmentSource def into ThingDef_PowerFist.");
return(result);
}
bool casterWearsPowerArmor = IsCasterWearingPowerArmor();
int repelDurationInTicks = (int)repelProperties.repelDurationInTicks;
float maxRepelDistance = 0;
float crushDamageFactor = 0;
float electricDamageFactor = 0;
float stunDurationInTicks = 0;
float empDurationInTicks = 0;
// Compute repel max distance and stun duration according to the target size. Flying squirrels!!! :D
if (casterWearsPowerArmor)
{
crushDamageFactor = repelProperties.crushDamageFactorWithPowerArmor;
electricDamageFactor = repelProperties.electricDamageFactorWithPowerArmor;
empDurationInTicks = repelProperties.empDurationInTicks;
if (targetPawn.BodySize <= repelProperties.bodySizeSmall)
{
maxRepelDistance = repelProperties.repelDistanceFactorWithPowerArmor * repelProperties.repelDistanceLong;
stunDurationInTicks = repelProperties.stunDurationInTicksLong;
}
else if (targetPawn.BodySize <= repelProperties.bodySizeMedium)
{
maxRepelDistance = repelProperties.repelDistanceFactorWithPowerArmor * repelProperties.repelDistanceMedium;
stunDurationInTicks = repelProperties.stunDurationInTicksMedium;
}
else if (targetPawn.BodySize <= repelProperties.bodySizeBig)
{
maxRepelDistance = repelProperties.repelDistanceFactorWithPowerArmor * repelProperties.repelDistanceShort;
stunDurationInTicks = repelProperties.stunDurationInTicksShort;
}
}
else
{
crushDamageFactor = repelProperties.crushDamageFactor;
electricDamageFactor = repelProperties.electricDamageFactor;
if (targetPawn.BodySize <= repelProperties.bodySizeSmall)
{
maxRepelDistance = repelProperties.repelDistanceLong;
stunDurationInTicks = repelProperties.stunDurationInTicksMedium;
}
else if (targetPawn.BodySize <= repelProperties.bodySizeMedium)
{
maxRepelDistance = repelProperties.repelDistanceMedium;
stunDurationInTicks = repelProperties.stunDurationInTicksShort;
}
}
// Start repel if target is not too big.
IntVec3 vector = targetPawn.Position - this.CasterPawn.Position;
if (maxRepelDistance > 0)
{
float repelDistance = 0f;
ThingDef obstacleDef = null;
PowerFistRepeller repeller = GenSpawn.Spawn(Util_PowerFist.PowerFistRepellerDef, targetPawn.Position, targetPawn.Map) as PowerFistRepeller;
repeller.Notify_BeginRepel(this.CasterPawn, targetPawn, vector, Mathf.FloorToInt(maxRepelDistance), repelDurationInTicks, out repelDistance, out obstacleDef);
if (obstacleDef != null)
{
Vector3 motePosition = targetPawn.Position.ToVector3Shifted() + vector.ToVector3() * repelDistance;
MoteMaker.ThrowText(motePosition, targetPawn.Map, "Crushed", Color.red);
int extraDamage = Mathf.RoundToInt(this.EquipmentSource.def.statBases.GetStatValueFromList(StatDefOf.MeleeWeapon_AverageDPS, 5f) * crushDamageFactor);
DamageInfo infos = new DamageInfo(DamageDefOf.Blunt, extraDamage, 0, vector.AngleFlat, this.caster, null, obstacleDef);
targetPawn.TakeDamage(infos);
}
}
if ((targetPawn != null) &&
(targetPawn.Dead ||
targetPawn.Downed))
{
// Do not try to apply stun if pawn is dead/downed.
return(result);
}
// Apply stun or EMP.
if (targetPawn.RaceProps.IsMechanoid)
{
if (casterWearsPowerArmor)
{
DamageInfo infos = new DamageInfo(DamageDefOf.EMP, Mathf.RoundToInt(empDurationInTicks / StunDurationFactor_EMP), 0, vector.AngleFlat, this.caster, null, this.EquipmentSource.def);
targetPawn.stances.stunner.Notify_DamageApplied(infos, true);
MoteMaker.ThrowExplosionInteriorMote(targetPawn.Position.ToVector3Shifted(), targetPawn.Map, ThingDef.Named("Mote_ElectricalSpark"));
int extraDamage = Mathf.RoundToInt(this.EquipmentSource.def.statBases.GetStatValueFromList(StatDefOf.MeleeWeapon_AverageDPS, 5) * electricDamageFactor);
DamageInfo infos2 = new DamageInfo(Util_PowerFist.ElectricDamageDef, extraDamage, 0, vector.AngleFlat, this.caster, null, this.EquipmentSource.def);
targetPawn.TakeDamage(infos2);
}
}
else if (stunDurationInTicks > 0)
{
DamageInfo infos = new DamageInfo(DamageDefOf.Stun, Mathf.RoundToInt(stunDurationInTicks / StunDurationFactor_Standard), 0, vector.AngleFlat, this.caster, null, this.EquipmentSource.def);
targetPawn.stances.stunner.Notify_DamageApplied(infos, false);
}
}
return(result);
}
/// <summary>Applies the special effects to part.</summary>
/// <param name="pawn">The pawn.</param>
/// <param name="totalDamage">The total damage.</param>
/// <param name="dinfo">The dinfo.</param>
/// <param name="result">The result.</param>
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
BodyPartRecord hitPart = dinfo.HitPart;
if (hitPart.depth == BodyPartDepth.Inside)
{
List <BodyPartRecord> list = new List <BodyPartRecord>();
for (BodyPartRecord bodyPartRecord = hitPart; bodyPartRecord != null; bodyPartRecord = bodyPartRecord.parent)
{
list.Add(bodyPartRecord);
if (bodyPartRecord.depth == BodyPartDepth.Outside)
{
break;
}
}
float num = (float)(list.Count - 1) + 0.5f;
for (int i = 0; i < list.Count; i++)
{
DamageInfo dinfo2 = dinfo;
dinfo2.SetHitPart(list[i]);
base.FinalizeAndAddInjury(pawn, totalDamage / num * ((i != 0) ? 1f : 0.5f), dinfo2, result);
}
if (Rand.Range(0, 1f) < 0.5f)
{
AddMutationOn(hitPart, pawn);
}
//add extra mutagenic buildup severity
AddExtraBuildup(pawn, dinfo);
}
else
{
float l = hitPart.def.IsSolid(hitPart, pawn.health.hediffSet.hediffs) ? 0.5f : 0.3f;
if (Rand.Range(0, 1f) < l)
{
AddMutationOn(hitPart, pawn);
}
int num2 = (this.def.cutExtraTargetsCurve == null) ? 0 : GenMath.RoundRandom(this.def.cutExtraTargetsCurve.Evaluate(Rand.Value));
List <BodyPartRecord> list2;
if (num2 != 0)
{
IEnumerable <BodyPartRecord> enumerable = hitPart.GetDirectChildParts();
if (hitPart.parent != null)
{
enumerable = enumerable.Concat(hitPart.parent);
if (hitPart.parent.parent != null)
{
enumerable = enumerable.Concat(hitPart.parent.GetDirectChildParts());
}
}
list2 = (from x in enumerable.Except(hitPart).InRandomOrder(null).Take(num2)
where !x.def.conceptual
select x).ToList <BodyPartRecord>();
}
else
{
list2 = new List <BodyPartRecord>();
}
list2.Add(hitPart);
float num3 = totalDamage * (1f + this.def.cutCleaveBonus) / ((float)list2.Count + this.def.cutCleaveBonus);
if (num2 == 0)
{
num3 = base.ReduceDamageToPreserveOutsideParts(num3, dinfo, pawn);
}
for (int j = 0; j < list2.Count; j++)
{
DamageInfo dinfo3 = dinfo;
dinfo3.SetHitPart(list2[j]);
base.FinalizeAndAddInjury(pawn, num3, dinfo3, result);
}
}
}
public static bool TakeDamage_Prefix(Thing __instance, DamageInfo dinfo, ref DamageWorker.DamageResult __result)
{
if (__instance as Pawn == null)
{
return(true);
}
else
{
//Log.Message("Own TakeDamage");
//Log.Message("Log1");
if (__instance.Destroyed)
{
__result = DamageWorker.DamageResult.MakeNew();
}
//Log.Message("Log2");
if (dinfo.Amount == 0)
{
__result = DamageWorker.DamageResult.MakeNew();
}
//Log.Message("Log3");
if (__instance.def.damageMultipliers != null)
{
for (int i = 0; i < __instance.def.damageMultipliers.Count; i++)
{
if (__instance.def.damageMultipliers[i].damageDef == dinfo.Def)
{
int amount = Mathf.RoundToInt((float)dinfo.Amount * __instance.def.damageMultipliers[i].multiplier);
dinfo.SetAmount(amount);
}
}
}
//Log.Message("Log4");
bool flag;
__instance.PreApplyDamage(dinfo, out flag);
if (flag)
{
__result = DamageWorker.DamageResult.MakeNew();
}
//Log.Message("Log5");
bool spawnedOrAnyParentSpawned = __instance.SpawnedOrAnyParentSpawned;
Map mapHeld = __instance.MapHeld;
DamageWorker.DamageResult result = dinfo.Def.Worker.Apply(dinfo, __instance);
if (dinfo.Def.harmsHealth && spawnedOrAnyParentSpawned)
{
mapHeld.damageWatcher.Notify_DamageTaken(__instance, result.totalDamageDealt);
}
//Log.Message("Log6");
if (dinfo.Def.externalViolence)
{
GenLeaving.DropFilthDueToDamage(__instance, result.totalDamageDealt);
if (dinfo.Instigator != null)
{
Pawn pawn = dinfo.Instigator as Pawn;
if (pawn != null)
{
pawn.records.AddTo(RecordDefOf.DamageDealt, result.totalDamageDealt);
pawn.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt);
}
}
}
//Log.Message("Log7");
__instance.PostApplyDamage(dinfo, result.totalDamageDealt);
__result = result;
return(false);
//return true;
}
}
public static bool TakeDamage(Thing __instance, ref DamageWorker.DamageResult __result, DamageInfo dinfo)
{
//---START change---
Map mapHeld = __instance.MapHeld; //moved
if (mapHeld == null)
{
__result = new DamageWorker.DamageResult();
return(false);
}
//---END change---
if (__instance.Destroyed)
{
__result = new DamageWorker.DamageResult();
return(false);
}
if ((double)dinfo.Amount == 0.0)
{
__result = new DamageWorker.DamageResult();
return(false);
}
if (__instance.def.damageMultipliers != null)
{
for (int index = 0; index < __instance.def.damageMultipliers.Count; ++index)
{
if (__instance.def.damageMultipliers[index].damageDef == dinfo.Def)
{
int num = Mathf.RoundToInt(dinfo.Amount * __instance.def.damageMultipliers[index].multiplier);
dinfo.SetAmount((float)num);
}
}
}
bool absorbed;
__instance.PreApplyDamage(ref dinfo, out absorbed);
if (absorbed)
{
__result = new DamageWorker.DamageResult();
return(false);
}
bool anyParentSpawned = __instance.SpawnedOrAnyParentSpawned;
// Map mapHeld = __instance.MapHeld; //moved
DamageWorker.DamageResult damageResult = dinfo.Def.Worker.Apply(dinfo, __instance);
if (dinfo.Def.harmsHealth & anyParentSpawned)
{
mapHeld.damageWatcher.Notify_DamageTaken(__instance, damageResult.totalDamageDealt);
}
if (dinfo.Def.ExternalViolenceFor(__instance))
{
#if RW13
if (dinfo.SpawnFilth)
#endif
GenLeaving.DropFilthDueToDamage(__instance, damageResult.totalDamageDealt);
if (dinfo.Instigator != null && dinfo.Instigator is Pawn instigator2)
{
if (instigator2 != null)
{
instigator2.records.AddTo(RecordDefOf.DamageDealt, damageResult.totalDamageDealt);
#if RW12
instigator2.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt);
#endif
}
}
}
__instance.PostApplyDamage(dinfo, damageResult.totalDamageDealt);
__result = damageResult;
return(false);
}
// Token: 0x06004B89 RID: 19337 RVA: 0x002347B4 File Offset: 0x00232BB4
protected float FinalizeAndAddInjury(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
if (pawn.health.hediffSet.PartIsMissing(dinfo.HitPart))
{
return(0f);
}
HediffDef hediffDefFromDamage = HealthUtility.GetHediffDefFromDamage(dinfo.Def, pawn, dinfo.HitPart);
Hediff_Injury hediff_Injury = (Hediff_Injury)HediffMaker.MakeHediff(hediffDefFromDamage, pawn, null);
hediff_Injury.Part = dinfo.HitPart;
hediff_Injury.source = dinfo.Weapon;
hediff_Injury.sourceBodyPartGroup = dinfo.WeaponBodyPartGroup;
hediff_Injury.sourceHediffDef = dinfo.WeaponLinkedHediff;
hediff_Injury.Severity = totalDamage;
if (dinfo.InstantPermanentInjury)
{
HediffComp_GetsPermanent hediffComp_GetsPermanent = hediff_Injury.TryGetComp <HediffComp_GetsPermanent>();
if (hediffComp_GetsPermanent != null)
{
hediffComp_GetsPermanent.IsPermanent = true;
}
else
{
Log.Error(string.Concat(new object[]
{
"Tried to create instant permanent injury on Hediff without a GetsPermanent comp: ",
hediffDefFromDamage,
" on ",
pawn
}), false);
}
}
return(this.FinalizeAndAddInjury(pawn, hediff_Injury, dinfo, result));
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
Pawn attacker = dinfo.Instigator as Pawn;
if (attacker != null)
{
if (attacker.health != null)
{
if (attacker.health.hediffSet.GetInjuriesTendable() != null && attacker.health.hediffSet.GetInjuriesTendable().Count <Hediff_Injury>() > 0)
{
foreach (Hediff_Injury injury in attacker.health.hediffSet.GetInjuriesTendable())
{
injury.Severity = injury.Severity - 15f;
break;
}
}
}
}
}
// Token: 0x06004B8A RID: 19338 RVA: 0x0023489C File Offset: 0x00232C9C
protected float FinalizeAndAddInjury(Pawn pawn, Hediff_Injury injury, DamageInfo dinfo, DamageWorker.DamageResult result)
{
HediffComp_GetsPermanent hediffComp_GetsPermanent = injury.TryGetComp <HediffComp_GetsPermanent>();
if (hediffComp_GetsPermanent != null)
{
hediffComp_GetsPermanent.PreFinalizeInjury();
}
pawn.health.AddHediff(injury, null, new DamageInfo?(dinfo), result);
float num = Mathf.Min(injury.Severity, pawn.health.hediffSet.GetPartHealth(injury.Part));
result.totalDamageDealt += num;
result.wounded = true;
result.AddPart(pawn, injury.Part);
result.AddHediff(injury);
return(num);
}
protected override void SpringSub(Pawn p)
{
int temp = UnityEngine.Random.Range(0, 5);
if (temp == 0)
{
for (int i = 0; i < 3; i++)
{
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDef.Named("Rat"), null);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(this.Position, this.Map, 2, (IntVec3 c) => c.Standable(this.Map) &&
this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
this.Map, WipeMode.Vanish);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
}
}
else if (temp == 1)
{
for (int i = 0; i < 2; i++)
{
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDef.Named("Cat"), null);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(this.Position, this.Map, 2, (IntVec3 c) => c.Standable(this.Map) &&
this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
this.Map, WipeMode.Vanish);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
}
}
else if (temp == 2)
{
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDef.Named("Cougar"), null);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(this.Position, this.Map, 2, (IntVec3 c) => c.Standable(this.Map) &&
this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
this.Map, WipeMode.Vanish);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
}
else if (temp == 3)
{
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDef.Named("WildBoar"), null);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(this.Position, this.Map, 2, (IntVec3 c) => c.Standable(this.Map) &&
this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
this.Map, WipeMode.Vanish);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
}
else
{
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDef.Named("Bear_Grizzly"), null);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
Thing spawnedCreature = GenSpawn.Spawn(pawn, CellFinder.RandomClosewalkCellNear(this.Position, this.Map, 2, (IntVec3 c) => c.Standable(this.Map) &&
this.Map.reachability.CanReach(c, this, PathEndMode.Touch, TraverseParms.For(TraverseMode.PassDoors, Danger.Deadly, false))),
this.Map, WipeMode.Vanish);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, true, false, null, false);
}
SoundDefOf.TrapSpring.PlayOneShot(new TargetInfo(base.Position, base.Map, false));
if (p == null)
{
return;
}
float num = this.GetStatValue(StatDefOf.TrapMeleeDamage, true) * DamageRandomFactorRange.RandomInRange * SRFPSRT_settings.Gettrapdamage();
float num2 = num / DamageCount;
float armorPenetration = num2 * 0.015f * SRFPSRT_settings.Getarmorpenetrate();
int num3 = 0;
while ((float)num3 < DamageCount)
{
DamageInfo dinfo = new DamageInfo(DamageDefOf.Stab, num2, armorPenetration, -1f, this, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null);
DamageWorker.DamageResult damageResult = p.TakeDamage(dinfo);
if (num3 == 0)
{
BattleLogEntry_DamageTaken battleLogEntry_DamageTaken = new BattleLogEntry_DamageTaken(p, RulePackDefOf.DamageEvent_TrapSpike, null);
Find.BattleLog.Add(battleLogEntry_DamageTaken);
damageResult.AssociateWithLog(battleLogEntry_DamageTaken);
}
num3++;
}
Map map = base.Map;
IntVec3 loc = this.Position;
this.Destroy(DestroyMode.Vanish);
Thing thing = GenSpawn.Spawn(ThingMaker.MakeThing(ThingDef.Named("Building_SRFPSRTunarmed"), this.Stuff), loc, map, WipeMode.Vanish);
thing.SetFaction(Faction.OfPlayer, null);
}
public override DamageResult Apply(DamageInfo dinfo, Thing thing)
{
DamageResult result = new DamageWorker.DamageResult();
result.totalDamageDealt = 0f;
if (thing is ProjectJedi.PawnGhost)
{
Messages.Message("PJ_ForceGhostResisted".Translate(), MessageTypeDefOf.NegativeEvent);
return(result);
}
Pawn pawn = thing as Pawn;
if (pawn != null)
{
if (dinfo.Instigator != null)
{
Pawn caster = dinfo.Instigator as Pawn;
if (caster != null)
{
CompForceUser victimForce = pawn.GetComp <CompForceUser>();
int maxInjuries = 2;
int maxHeals = 0;
int maxPoolDamage = 30;
if (victimForce != null)
{
if (victimForce.IsForceUser)
{
Need_ForcePool victimForcePool = victimForce.ForcePool;
if (victimForcePool != null)
{
if (victimForcePool.CurLevel > 0.1f)
{
//Turn 0.01f into 1, or 1.0 into 100.
int victimForceInt = System.Convert.ToInt32(victimForcePool.CurLevel * 100);
//Log.Message("Victim Force Pool = " + victimForceInt.ToString());
Need_ForcePool casterPool = caster.needs.TryGetNeed <Need_ForcePool>();
if (casterPool != null)
{
Messages.Message("PJ_ForceDrainOne".Translate(new object[]
{
caster.Label,
pawn.Label
}), MessageTypeDefOf.SilentInput);
for (int i = 0; i < Mathf.Min(victimForceInt, maxPoolDamage); i++)
{
if (casterPool.CurLevel >= 0.99f)
{
break;
}
casterPool.CurLevel += 0.01f;
victimForcePool.CurLevel -= 0.05f;
}
return(result);
}
}
}
}
}
Messages.Message("PJ_ForceDrainTwo".Translate(new object[]
{
caster.Label,
pawn.Label
}), MessageTypeDefOf.SilentInput);
foreach (BodyPartRecord rec in pawn.health.hediffSet.GetNotMissingParts().InRandomOrder <BodyPartRecord>())
{
if (maxInjuries > 0)
{
pawn.TakeDamage(new DamageInfo(DamageDefOf.Burn, new IntRange(5, 10).RandomInRange, 1f, -1, caster, rec));
maxInjuries--;
maxHeals++;
}
}
int maxInjuriesPerBodypart;
foreach (BodyPartRecord rec in caster.health.hediffSet.GetInjuredParts())
{
if (maxHeals > 0)
{
maxInjuriesPerBodypart = 2;
foreach (Hediff_Injury current in from injury in caster.health.hediffSet.GetHediffs <Hediff_Injury>() where injury.Part == rec select injury)
{
if (maxInjuriesPerBodypart > 0)
{
if (current.CanHealNaturally() && !current.IsPermanent()) // basically check for scars and old wounds
{
current.Heal((int)current.Severity + 1);
maxHeals--;
maxInjuriesPerBodypart--;
}
}
}
}
}
}
}
}
return(result);
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
Pawn_SwallowWhole attacker = dinfo.Instigator as Pawn_SwallowWhole;
if (attacker != null && attacker.Map != null && !pawn.Downed && !pawn.Dead && pawn.def.defName != "AA_PhoenixOwlcat")
{
CompSwallowWhole comp = attacker.TryGetComp <CompSwallowWhole>();
if (comp != null && attacker.innerContainer.Count < comp.Props.stomachCapacity && pawn.RaceProps.baseBodySize < comp.Props.maximumBodysize)
{
attacker.needs.food.CurLevel += comp.Props.nutritionGained;
HealthUtility.DamageUntilDowned(pawn);
if (comp.Props.soundPlayedWhenEating != null)
{
SoundDef.Named(comp.Props.soundPlayedWhenEating).PlayOneShot(new TargetInfo(attacker.Position, attacker.Map, false));
}
if (comp.Props.sendLetterWhenEating && pawn != null && pawn.Faction != null && pawn.Faction.IsPlayer)
{
Find.LetterStack.ReceiveLetter(comp.Props.letterLabel.Translate(), comp.Props.letterText.Translate(pawn), LetterDefOf.ThreatBig, attacker, null, null);
}
attacker.TryAcceptThing(pawn);
}
}
}
protected override void ApplySpecialEffectsToPart(Pawn pawn, float totalDamage, DamageInfo dinfo, DamageWorker.DamageResult result)
{
base.ApplySpecialEffectsToPart(pawn, totalDamage, dinfo, result);
if (pawn.RaceProps.FleshType == FleshTypeDefOf.Mechanoid)
{
pawn.TakeDamage(new DamageInfo(DamageDefOf.EMP, 30, 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
}
}
protected override bool TryCastShot()
{
// power affects enumerator
DamageWorker.DamageResult result = DamageWorker.DamageResult.MakeNew();
Pawn caster = this.CasterPawn;
CompAbilityUserMagic comp = caster.GetComp <CompAbilityUserMagic>();
MagicPowerSkill pwr = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_Heal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_Heal_pwr");
MagicPowerSkill ver = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_Heal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_Heal_ver");
if (caster.story.traits.HasTrait(TorannMagicDefOf.Priest))
{
pwr = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_AdvancedHeal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_AdvancedHeal_pwr");
ver = caster.GetComp <CompAbilityUserMagic>().MagicData.MagicPowerSkill_AdvancedHeal.FirstOrDefault((MagicPowerSkill x) => x.label == "TM_AdvancedHeal_ver");
}
pwrVal = pwr.level;
verVal = ver.level;
if (caster.story.traits.HasTrait(TorannMagicDefOf.Faceless))
{
MightPowerSkill mpwr = caster.GetComp <CompAbilityUserMight>().MightData.MightPowerSkill_Mimic.FirstOrDefault((MightPowerSkill x) => x.label == "TM_Mimic_pwr");
MightPowerSkill mver = caster.GetComp <CompAbilityUserMight>().MightData.MightPowerSkill_Mimic.FirstOrDefault((MightPowerSkill x) => x.label == "TM_Mimic_ver");
pwrVal = mpwr.level;
verVal = mver.level;
}
Pawn pawn = (Pawn)this.currentTarget;
bool flag = pawn != null && !pawn.Dead;
if (flag)
{
int num = 3 + verVal;
using (IEnumerator <BodyPartRecord> enumerator = pawn.health.hediffSet.GetInjuredParts().GetEnumerator())
{
while (enumerator.MoveNext())
{
BodyPartRecord rec = enumerator.Current;
bool flag2 = num > 0;
if (flag2)
{
int num2 = 1 + verVal;
ModOptions.SettingsRef settingsRef = new ModOptions.SettingsRef();
if (!this.CasterPawn.IsColonist && settingsRef.AIHardMode)
{
num2 = 5;
}
IEnumerable <Hediff_Injury> arg_BB_0 = pawn.health.hediffSet.GetHediffs <Hediff_Injury>();
Func <Hediff_Injury, bool> arg_BB_1;
arg_BB_1 = ((Hediff_Injury injury) => injury.Part == rec);
foreach (Hediff_Injury current in arg_BB_0.Where(arg_BB_1))
{
bool flag4 = num2 > 0;
if (flag4)
{
bool flag5 = current.CanHealNaturally() && !current.IsOld();
if (flag5)
{
//current.Heal((float)((int)current.Severity + 1));
if (!this.CasterPawn.IsColonist)
{
current.Heal(20.0f + (float)pwrVal * 3f); // power affects how much to heal
}
else
{
current.Heal((5.0f + (float)pwrVal * 3f) * comp.arcaneDmg); // power affects how much to heal
}
TM_MoteMaker.ThrowRegenMote(pawn.Position.ToVector3Shifted(), pawn.Map, .6f);
TM_MoteMaker.ThrowRegenMote(pawn.Position.ToVector3Shifted(), pawn.Map, .4f);
num--;
num2--;
}
}
}
}
}
}
}
return(true);
}
