public static Action TryCastPowerAction(Pawn pawn, LocalTargetInfo target, CompPsyker compPsyker, Verb_CastWarpPower verb, PsykerPowerDef psydef)
{
Action act = new Action(delegate
{
// compPsyker.TicksToCast = verb.warpverbprops.TicksToRecharge;
// compPsyker.TicksToCastMax = verb.warpverbprops.TicksToRecharge;
compPsyker.CurTarget = null;
compPsyker.CurTarget = target;
compPsyker.curVerb = verb;
compPsyker.curPower = psydef;
// Log.Message("Casting Stuff");
// Log.Message(compPsyker.curPower.defName);
compPsyker.curRotation = target.Thing.Rotation;
Job job = CompPsyker.PsykerJob(verb.warpverbprops.PsykerPowerCategory, target);
job.playerForced = true;
job.verbToUse = verb;
Pawn pawn2 = target.Thing as Pawn;
if (pawn2 != null)
{
job.killIncappedTarget = pawn2.Downed;
}
pawn.jobs.TryTakeOrderedJob(job);
});
return(act);
}
public static void PsykerShockEvents(CompPsyker psycomp, PsykerPowerLevel spellPowerLevel)
{
float chance = CalculatePsykerShockProbability(psycomp, spellPowerLevel);
if (Rand.Range(0f, 1f) < chance)
{
float severity = Rand.Range(0f, 1f);
if (severity < 0.1f)
{
psycomp.psyker.health.AddHediff(CorruptionDefOfs.DemonicPossession);
return;
}
else if (severity < 0.3f)
{
Hediff hediff = HediffMaker.MakeHediff(HediffDefOf.PsychicShock, psycomp.psyker, null);
psycomp.psyker.health.AddHediff(hediff, null, null);
return;
}
else
{
Job vomit = new Job(JobDefOf.Vomit);
vomit.playerForced = true;
psycomp.psyker.jobs.StartJob(vomit, JobCondition.InterruptForced, null, false, true, null);
return;
}
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
Pawn Reader = this.pawn;
Need_Soul soul = Reader.needs.TryGetNeed <Need_Soul>();
CompPsyker compPsyker = soul.compPsyker;
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
}
private static float CalculatePsykerShockProbability(CompPsyker psycomp, PsykerPowerLevel spellPowerLevel)
{
float num = 0f;
int psykerPower = (int)psycomp.soul.PsykerPowerLevel;
int spellPower = (int)spellPowerLevel;
num = 0.2f - (Mathf.Pow(spellPower - psykerPower, 2)) / 100;
if (num < 0.01f)
{
num = 0.01f;
}
return(num);
}
public void CheckForOwner()
{
CompEquippable tempcomp;
Apparel tempthing;
if (this.parent != null && !this.parent.Spawned)
{
// Log.Message("Begin Check");
if (this.parent is Apparel)
{
// Log.Message("Soul item is Apparel");
tempthing = this.parent as Apparel;
this.Owner = tempthing.wearer;
}
else if ((tempcomp = this.parent.TryGetComp <CompEquippable>()) != null && tempcomp.PrimaryVerb.CasterPawn != null)
{
// Log.Message("IsGun");
this.Owner = tempcomp.PrimaryVerb.CasterPawn;
}
if ((this.Owner != null))
{
if ((soul = this.Owner.needs.TryGetNeed <Need_Soul>()) != null)
{
this.CalculateSoulChanges(soul);
}
if (!PsykerPowerAdded)
{
CompPsyker compPsyker;
if ((compPsyker = Owner.TryGetComp <CompPsyker>()) != null)
{
for (int i = 0; i < SProps.UnlockedPsykerPowers.Count; i++)
{
if (soul.PsykerPowerLevel <= SProps.UnlockedPsykerPowers[i].PowerLevel)
{
compPsyker.temporaryWeaponPowers.Add(new PsykerPower(Owner, SProps.UnlockedPsykerPowers[i]));
}
}
compPsyker.UpdatePowers();
this.LastOwner = compPsyker;
}
PsykerPowerAdded = true;
}
}
}
if (this.parent.Spawned && this.LastOwner != null)
{
LastOwner.temporaryWeaponPowers.Clear();
LastOwner.UpdatePowers();
PsykerPowerAdded = false;
}
}
public void InitiatePsykerComp()
{
CompPsyker compPsyker = new CompPsyker();
compPsyker.parent = this.pawn;
CompProperties_PsykerVerb cprops = new CompProperties_PsykerVerb();
cprops.compClass = typeof(CompPsyker);
compPsyker.Initialize(cprops);
FieldInfo info = typeof(ThingWithComps).GetField("comps", BindingFlags.NonPublic | BindingFlags.Instance);
if (info != null)
{
List <ThingComp> list = info.GetValue(this.pawn) as List <ThingComp>;
list.Add(compPsyker);
typeof(ThingWithComps).GetField("comps", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(this.pawn, list);
}
compPsyker.PostSpawnSetup();
this.compPsyker = compPsyker;
}
public static void __RenderPawnInternalPostFix(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = 0, bool portrait = false)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
Vector3 vector = rootLoc;
Corruption.CompPsyker compPsyker = pawn.TryGetComp <CompPsyker>();
List <HediffComp_DrawImplant> implantDrawers = HarmonyPatches.implantDrawers(pawn);
string patronName = "Emperor";
bool drawChaos = false;
if (compPsyker != null)
{
patronName = compPsyker.patronName;
// Log.Message("GettingComp: " + patronName);
if (patronName == "Khorne" || patronName == "Nurgle" || patronName == "Tzeentch" || patronName == "Undivided")
{
// Log.Message("drawChaos");
drawChaos = true;
}
}
}
public PsykerPowerManager(CompPsyker compPsyker)
{
this.compPsyker = compPsyker;
}
public IEnumerable <Command_CastPower> GetPsykerVerbsNew()
{
// Log.Message("Found temp powers: " + this.temporaryPowers.Count.ToString() + " while finding Verbs: " + temporaryPowers.Count.ToString());
// Log.Message(this.PowerVerbs.Count.ToString());
List <Verb_CastWarpPower> temp = new List <Verb_CastWarpPower>();
temp.AddRange(this.PowerVerbs);
for (int i = 0; i < temp.Count; i++)
{
int j = i;
Verb_CastWarpPower newverb = temp[j];
newverb.caster = this.psyker;
newverb.verbProps = temp[j].verbProps;
Command_CastPower command_CastPower = new Command_CastPower(this);
command_CastPower.verb = newverb;
command_CastPower.defaultLabel = allPowers[j].def.LabelCap;
command_CastPower.defaultDesc = allPowers[j].def.description;
command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
{
command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
}
command_CastPower.icon = allPowers[j].def.uiIcon;
string str;
if (FloatMenuUtility.GetAttackAction(this.psyker, TargetInfo.Invalid, out str) == null)
{
command_CastPower.Disable(str.CapitalizeFirst() + ".");
}
command_CastPower.action = delegate(Thing target)
{
Action attackAction = CompPsyker.TryCastPowerAction(psyker, target, this, newverb, allPowers[j].def as PsykerPowerDef);
if (attackAction != null)
{
attackAction();
}
};
if (newverb.caster.Faction != Faction.OfPlayer)
{
command_CastPower.Disable("CannotOrderNonControlled".Translate());
}
if (newverb.CasterIsPawn)
{
if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
{
command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!newverb.CasterPawn.drafter.Drafted)
{
command_CastPower.Disable("IsNotDrafted".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!this.IsActive)
{
command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
}
yield return(command_CastPower);
}
yield break;
}
public Command_CastPower(CompPsyker compPsyker)
{
this.compPsyker = compPsyker;
}
private static void RenderPawnInternal(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = RotDrawMode.Fresh, bool portrait = false)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (!pawn.def.race.Humanlike)
{
return;
}
Corruption.CompPsyker compPsyker = pawn.TryGetComp <CompPsyker>();
List <HediffComp_DrawImplant> implantDrawers = HarmonyPatches.implantDrawers(pawn);
string patronName = "Emperor";
bool drawChaos = false;
if (compPsyker != null)
{
patronName = compPsyker.patronName;
// Log.Message("GettingComp: " + patronName);
if (patronName == "Khorne" || patronName == "Nurgle" || patronName == "Tzeentch" || patronName == "Undivided")
{
// Log.Message("drawChaos");
drawChaos = true;
}
}
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
if (renderBody)
{
Vector3 loc = rootLoc;
loc.y += 0.005f;
if (bodyDrawType == RotDrawMode.Dessicated && !pawn.RaceProps.Humanlike && __instance.graphics.dessicatedGraphic != null && !portrait)
{
__instance.graphics.dessicatedGraphic.Draw(loc, bodyFacing, pawn);
}
else
{
ThingDef_AlienRace alienDef = pawn.def as ThingDef_AlienRace;
if (alienDef != null)
{
Mesh mesh2;
if (bodyDrawType == RotDrawMode.Rotting)
{
if (__instance.graphics.dessicatedGraphic.ShouldDrawRotated)
{
mesh2 = MeshPool.GridPlane(portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.CustomPortraitDrawSize : alienDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize);
}
else
{
Vector2 size = portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.CustomPortraitDrawSize : alienDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize;
if (bodyFacing.IsHorizontal)
{
size = size.Rotated();
}
if (bodyFacing == Rot4.West && (__instance.graphics.dessicatedGraphic.data == null || __instance.graphics.dessicatedGraphic.data.allowFlip))
{
mesh = MeshPool.GridPlaneFlip(size);
}
mesh = MeshPool.GridPlane(size);
}
}
else
{
mesh = (portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.bodyPortraitSet.MeshAt(bodyFacing) : alienDef.alienRace.generalSettings.alienPartGenerator.bodySet.MeshAt(bodyFacing));
}
}
else
{
if (pawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = __instance.graphics.nakedGraphic.MeshAt(bodyFacing);
}
}
List <Material> list = __instance.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
// Material damagedMat = __instance.graphics.flasher.GetDamagedMat(list[i]);
// GenDraw.DrawMeshNowOrLater(mesh, loc, quat, damagedMat, portrait);
loc.y += 0.005f;
if (i == 0)
{
if (drawChaos)
{
Material markMat = (Corruption.AfflictionDrawerUtility.GetBodyOverlay(pawn.story.bodyType, patronName).MatAt(bodyFacing));
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
markMat.mainTextureScale = new Vector2(1, 1.3f);
markMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
markMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, markMat, portrait);
loc.y += 0.005f;
}
}
if (bodyDrawType == RotDrawMode.Fresh)
{
Vector3 drawLoc = rootLoc;
drawLoc.y += 0.02f;
// Traverse.Create(__instance).Field("woundOverlays").GetValue<PawnWoundDrawer>().RenderOverBody(drawLoc, mesh, quat, portrait);
}
}
}
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.03f;
vector.y += 0.0249999985f;
}
else
{
a.y += 0.0249999985f;
vector.y += 0.03f;
}
if (__instance.graphics.headGraphic != null)
{
Vector3 b = quat * __instance.BaseHeadOffsetAt(headFacing);
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
Material mat = __instance.graphics.HeadMatAt(headFacing, bodyDrawType);
// GenDraw.DrawMeshNowOrLater(mesh2, a + b, quat, mat, portrait);
if (drawChaos)
{
Material headMarkMat = (AfflictionDrawerUtility.GetHeadGraphic(pawn, patronName).MatAt(bodyFacing));
// vector.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh2, a + b + new Vector3(0f, 0.004f, 0f), quat, headMarkMat, portrait);
}
Vector3 loc2 = rootLoc + b;
loc2.y += 0.035f;
bool flag = false;
Mesh mesh3 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
flag = true;
Material material = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material = __instance.graphics.flasher.GetDamagedMat(material);
// GenDraw.DrawMeshNowOrLater(mesh3, loc2, quat, material, portrait);
}
if (!flag && bodyDrawType != RotDrawMode.Dessicated)
{
Mesh mesh4 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
Material mat2 = __instance.graphics.HairMatAt(headFacing);
// GenDraw.DrawMeshNowOrLater(mesh4, loc2, quat, mat2, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < __instance.graphics.apparelGraphics.Count; k++)
{
Material pauldronMat;
if (CompPauldronDrawer.ShouldDrawPauldron(pawn, __instance.graphics.apparelGraphics[k].sourceApparel, bodyFacing, out pauldronMat))
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
pauldronMat.mainTextureScale = new Vector2(1.00f, 1.22f);
pauldronMat.mainTextureOffset = new Vector2(0, -0.1f);
}
vector.y += 0.035f;
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, pauldronMat, portrait);
}
ApparelGraphicRecord apparelGraphicRecord = __instance.graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
// Material material2 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
// material2 = __instance.graphics.flasher.GetDamagedMat(material2);
// GenDraw.DrawMeshNowOrLater(mesh, vector, quat, material2, portrait);
}
if (!pawn.Dead)
{
for (int l = 0; l < pawn.health.hediffSet.hediffs.Count; l++)
{
HediffComp_DrawImplant drawer;
if ((drawer = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_DrawImplant>()) != null)
{
if (drawer.implantDrawProps.implantDrawerType != ImplantDrawerType.Head)
{
vector.y += 0.005f;
if (bodyFacing == Rot4.South && drawer.implantDrawProps.implantDrawerType == ImplantDrawerType.Backpack)
{
vector.y -= 0.3f;
}
Material implantMat = drawer.ImplantMaterial(pawn, bodyFacing);
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, implantMat, portrait);
vector.y += 0.005f;
}
}
}
}
}
}
}
}
}
public IEnumerable <Command_CastPower> GetPsykerVerbsNewV3()
{
// Log.Message("INIT");
foreach (PsykerPowerEntry current in this.allpsykerPowers)
{
// Log.Message("A");
if (PsykerHasEquipment(current))
{
Verb_CastWarpPower newverb = (Verb_CastWarpPower)Activator.CreateInstance(current.psykerPowerDef.MainVerb.verbClass);
newverb.caster = this.psyker;
newverb.verbProps = current.psykerPowerDef.MainVerb;
// Log.Message("B");
Command_CastPower command_CastPower = new Command_CastPower(this);
command_CastPower.verb = newverb;
command_CastPower.defaultLabel = current.psykerPowerDef.LabelCap;
command_CastPower.defaultDesc = current.psykerPowerDef.description;
// Log.Message("C");
command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
{
command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
}
// Log.Message("C2");
command_CastPower.icon = current.psykerPowerDef.uiIcon;
// Log.Message("D1");
string str;
if (FloatMenuUtility.GetAttackAction(this.psyker, LocalTargetInfo.Invalid, out str) == null)
{
command_CastPower.Disable(str.CapitalizeFirst() + ".");
}
// Log.Message("D");
command_CastPower.action = delegate(Thing target)
{
CompPsyker.TryCastPowerAction(psyker, target, this, newverb, current.psykerPowerDef as PsykerPowerDef)?.Invoke();
};
if (newverb.caster.Faction != Faction.OfPlayer)
{
command_CastPower.Disable("CannotOrderNonControlled".Translate());
}
if (newverb.CasterIsPawn)
{
if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
{
command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!newverb.CasterPawn.drafter.Drafted)
{
command_CastPower.Disable("IsNotDrafted".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!this.IsActive)
{
command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
}
yield return(command_CastPower);
}
}
yield break;
}
public IEnumerable <Command_CastPower> GetPsykerVerbsNew()
{
foreach (KeyValuePair <PsykerPower, Verb_CastWarpPower> entry in this.psykerPowers)
{
Verb_CastWarpPower newverb = entry.Value;
newverb.caster = this.psyker;
newverb.verbProps = entry.Value.verbProps;
Command_CastPower command_CastPower = new Command_CastPower(this);
command_CastPower.verb = newverb;
command_CastPower.defaultLabel = entry.Key.def.LabelCap;
command_CastPower.defaultDesc = entry.Key.def.description;
command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
{
command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
}
command_CastPower.icon = entry.Key.def.uiIcon;
string str;
if (FloatMenuUtility.GetAttackAction(this.psyker, LocalTargetInfo.Invalid, out str) == null)
{
command_CastPower.Disable(str.CapitalizeFirst() + ".");
}
command_CastPower.action = delegate(Thing target)
{
Action attackAction = CompPsyker.TryCastPowerAction(psyker, target, this, newverb, entry.Key.def as PsykerPowerDef);
if (attackAction != null)
{
attackAction();
}
};
if (newverb.caster.Faction != Faction.OfPlayer)
{
command_CastPower.Disable("CannotOrderNonControlled".Translate());
}
if (newverb.CasterIsPawn)
{
if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
{
command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!newverb.CasterPawn.drafter.Drafted)
{
command_CastPower.Disable("IsNotDrafted".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
else if (!this.IsActive)
{
command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
{
newverb.CasterPawn.NameStringShort
}));
}
}
yield return(command_CastPower);
}
yield break;
}
public static bool _RenderPawnInternal(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = 0, bool portrait = false)
{
Log.Message("Calling");
PawnRenderer renderer = __instance;
if (!renderer.graphics.AllResolved)
{
renderer.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
Pawn pawn = (Pawn)HarmonyPatches.pawnInfo.GetValue(renderer);
if (pawn is AlienPawn && (pawn as AlienPawn).bodySet == null)
{
(pawn as AlienPawn).UpdateSets();
}
Corruption.CompPsyker compPsyker = pawn.TryGetComp <CompPsyker>();
List <HediffComp_DrawImplant> implantDrawers = HarmonyPatches.implantDrawers(pawn);
string patronName = "Emperor";
bool drawChaos = false;
if (compPsyker != null)
{
patronName = compPsyker.patronName;
// Log.Message("GettingComp: " + patronName);
if (patronName == "Khorne" || patronName == "Nurgle" || patronName == "Tzeentch" || patronName == "Undivided")
{
// Log.Message("drawChaos");
drawChaos = true;
}
}
if (renderBody || (pawn.InBed() && pawn.ageTracker.CurLifeStageIndex <= 1))
{
if (pawn.RaceProps.Humanlike)
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
rootLoc.z -= 0.15f;
}
if (pawn.ageTracker.CurLifeStageIndex < 2 && pawn.InBed() && !portrait)
{
// Undo the offset for babies/toddlers in bed
Building_Bed building_bed = pawn.CurrentBed();
Vector3 offset = new Vector3(0, 0, 0.5f).RotatedBy(building_bed.Rotation.AsAngle);
rootLoc -= offset;
}
}
Vector3 vector = rootLoc;
vector.y += 0.005f;
if (bodyDrawType == RotDrawMode.Dessicated && !pawn.RaceProps.Humanlike && renderer.graphics.dessicatedGraphic != null && !portrait)
{
renderer.graphics.dessicatedGraphic.Draw(vector, bodyFacing, pawn);
}
else
{
bool humanlike = pawn.RaceProps.Humanlike;
if (humanlike)
{
mesh = ((pawn is AlienPawn) ? (pawn as AlienPawn).bodySet : MeshPool.humanlikeBodySet).MeshAt(bodyFacing);
}
else
{
mesh = renderer.graphics.nakedGraphic.MeshAt(bodyFacing);
}
List <Material> list = renderer.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material damagedMat = renderer.graphics.flasher.GetDamagedMat(list[i]);
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
damagedMat.mainTextureScale = new Vector2(1, 1.3f);
damagedMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
damagedMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, damagedMat, portrait);
vector.y += 0.003f;
if (i == 0)
{
if (drawChaos)
{
Material markMat = (Corruption.AfflictionDrawerUtility.GetBodyOverlay(pawn.story.bodyType, patronName).MatAt(bodyFacing));
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
markMat.mainTextureScale = new Vector2(1, 1.3f);
markMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
markMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, markMat, portrait);
vector.y += 0.003f;
}
}
}
if (bodyDrawType == 0)
{
Vector3 vector2 = rootLoc;
vector2.y += 0.02f;
((PawnWoundDrawer)HarmonyPatches.woundInfo.GetValue(renderer)).RenderOverBody(vector2, mesh, quat, portrait);
}
}
}
Vector3 vector3 = rootLoc;
Vector3 vector4 = rootLoc;
if (bodyFacing != Rot4.North)
{
vector4.y += 0.03f;
vector3.y += 0.0249999985f;
}
else
{
vector4.y += 0.0249999985f;
vector3.y += 0.03f;
}
if (renderer.graphics.headGraphic != null && pawn.ageTracker.CurLifeStageIndex >= 1)
{
Vector3 vector5 = quat * renderer.BaseHeadOffsetAt(headFacing);
Mesh mesh2 = ((pawn is AlienPawn) ? (pawn as AlienPawn).headSet : MeshPool.humanlikeHeadSet).MeshAt(headFacing);
Material material = renderer.graphics.HeadMatAt(headFacing, bodyDrawType);
GenDraw.DrawMeshNowOrLater(mesh2, vector4 + vector5, quat, material, portrait);
if (drawChaos)
{
Material headMarkMat = (AfflictionDrawerUtility.GetHeadGraphic(pawn, patronName).MatAt(bodyFacing));
vector5.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh2, vector4 + vector5, quat, headMarkMat, portrait);
}
Vector3 vector6 = rootLoc + vector5;
vector6.y += 0.035f;
bool flag7 = false;
if (pawn.ageTracker.CurLifeStageIndex >= 2)
{
Mesh mesh3 = HarmonyPatches.HairMeshSet(pawn).MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = renderer.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
if ((!pawn.story.hairDef.hairTags.Contains("DrawUnderHat") && !pawn.story.hairDef.hairTags.Contains("Beard")) || pawn.apparel.BodyPartGroupIsCovered(BodyPartGroupDefOf.FullHead))
{
flag7 = true; // flag=true stops the hair from being drawn
}
Material material2 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material2 = renderer.graphics.flasher.GetDamagedMat(material2);
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
material2.mainTextureOffset = new Vector2(0, 0.018f);
material2.mainTexture.wrapMode = TextureWrapMode.Clamp;
}
GenDraw.DrawMeshNowOrLater(mesh3, vector6, quat, material2, portrait);
Material detailMat;
if (ApparelDetailDrawer.GetDetailGraphic(pawn, apparelGraphics[j].sourceApparel, bodyFacing, out detailMat))
{
Vector3 vectorDet = vector6;
vectorDet.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh3, vectorDet, quat, detailMat, portrait);
}
}
}
}
if (!flag7 && bodyDrawType != RotDrawMode.Dessicated)
{
Mesh mesh4 = HarmonyPatches.HairMeshSet(pawn).MeshAt(headFacing);
Material material3 = renderer.graphics.HairMatAt(headFacing);
// Hopefully stops graphic issues from modifying texture offset/scale
material3.mainTexture.wrapMode = TextureWrapMode.Clamp;
// Scale down the child hair to fit the head
if (pawn.ageTracker.CurLifeStageIndex <= 2)
{
material3.mainTextureScale = new Vector2(1.13f, 1.13f);
material3.mainTextureOffset = new Vector2(-0.065f, -0.045f);
}
// Scale down the toddler hair to fit the head
if (pawn.ageTracker.CurLifeStageIndex == 1)
{
// mat2.mainTextureScale = new Vector2 (1.25f, 1.25f);
material3.mainTextureOffset = new Vector2(-0.07f, 0.12f);
}
GenDraw.DrawMeshNowOrLater(mesh4, vector6, quat, material3, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < renderer.graphics.apparelGraphics.Count; k++)
{
ApparelGraphicRecord apparelGraphicRecord = renderer.graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
Material material4 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
material4 = renderer.graphics.flasher.GetDamagedMat(material4);
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
material4.mainTextureScale = new Vector2(1.00f, 1.22f);
material4.mainTextureOffset = new Vector2(0, -0.1f);
}
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, material4, portrait);
}
Material pauldronMat;
if (CompPauldronDrawer.ShouldDrawPauldron(pawn, renderer.graphics.apparelGraphics[k].sourceApparel, bodyFacing, out pauldronMat))
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
pauldronMat.mainTextureScale = new Vector2(1.00f, 1.22f);
pauldronMat.mainTextureOffset = new Vector2(0, -0.1f);
}
vector3.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, pauldronMat, portrait);
}
}
if (!pawn.Dead)
{
for (int l = 0; l < pawn.health.hediffSet.hediffs.Count; l++)
{
HediffComp_DrawImplant drawer;
if ((drawer = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_DrawImplant>()) != null)
{
if (drawer.implantDrawProps.implantDrawerType != ImplantDrawerType.Head)
{
vector3.y += 0.005f;
if (bodyFacing == Rot4.South && drawer.implantDrawProps.implantDrawerType == ImplantDrawerType.Backpack)
{
vector3.y -= 0.3f;
}
Material implantMat = drawer.ImplantMaterial(pawn, bodyFacing);
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, implantMat, portrait);
vector3.y += 0.005f;
}
}
}
}
}
if (!portrait && pawn.RaceProps.Animal && pawn.inventory != null && pawn.inventory.innerContainer.Count() > 0)
{
Graphics.DrawMesh(mesh, vector3, quat, renderer.graphics.packGraphic.MatAt(pawn.Rotation, null), 0);
}
if (!portrait)
{
HarmonyPatches.equipInfo.Invoke(renderer, new object[]
{
rootLoc
});
if (pawn.apparel != null)
{
List <Apparel> wornApparel = pawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
Vector3 vector7 = rootLoc;
vector7.y += 0.0449999981f;
((PawnHeadOverlays)HarmonyPatches.statusInfo.GetValue(renderer)).RenderStatusOverlays(vector7, quat, ((pawn is AlienPawn) ? (pawn as AlienPawn).headSet : MeshPool.humanlikeHeadSet).MeshAt(headFacing));
}
return(false);
}
