Exemple #1
0
 static void Postfix(Pawn_DrawTracker __instance)
 {
     if (__instance.leaner is ZombieLeaner zombieLeaner)
     {
         zombieLeaner.ZombieTick();
     }
 }
        public override void CompPostMake()
        {
            Pawn             pawn        = this.parent.pawn as Pawn;
            Pawn_DrawTracker drawtracker = ((Pawn_DrawTracker)typeof(Pawn).GetField("drawer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(pawn));

            if (drawtracker != null)
            {
                this.pawn_renderer = drawtracker.renderer;
            }
            Vector2 vector = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.drawSize * 3;

            LongEventHandler.ExecuteWhenFinished(delegate
            {
                if (this.pawn_renderer != null)
                {
                    try
                    {
                        Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath + "_Enlarged", ShaderDatabase.Cutout, vector, Color.white);
                        this.pawn_renderer.graphics.ResolveAllGraphics();
                        this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                        (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                    }
                    catch (NullReferenceException) { }
                }
            });
        }
Exemple #3
0
 static void Postfix(Pawn_DrawTracker __instance, ref Vector3 __result)
 {
     if (__instance.leaner is ZombieLeaner zombieLeaner)
     {
         __result += zombieLeaner.ZombieOffset;
     }
 }
        //RenderPawnAt_PostFix
        // Verse.PawnRenderer
        public static void DrawAt_PostFix(Pawn_DrawTracker __instance, Vector3 loc)
        {
            Pawn pawn = (Pawn)AccessTools.Field(typeof(Pawn_DrawTracker), "pawn").GetValue(__instance);

            if (pawn?.GetComp <CompTransmogrified>() is CompTransmogrified compTrans && compTrans.IsTransmogrified &&
                pawn.Spawned)
            {
                Material matSingle;
                matSingle = CultsDefOf.Cults_TransmogAura.graphicData.Graphic.MatSingle;

                float angle = 0f;
                angle = pawn.Rotation.AsAngle + (compTrans.Hediff.UndulationTicks * 100);

                float xCap = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.x + 0.5f;
                float zCap = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.y + 0.5f;

                float x     = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.x;
                float z     = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.y;
                float drawX = Mathf.Clamp((x + compTrans.Hediff.UndulationTicks) * compTrans.Hediff.graphicDiv, 0.01f,
                                          xCap);
                float drawY = Altitudes.AltitudeFor(AltitudeLayer.Terrain);
                float drawZ = Mathf.Clamp((z + compTrans.Hediff.UndulationTicks) * compTrans.Hediff.graphicDiv, 0.01f,
                                          zCap);
                Vector3   s      = new Vector3(drawX, drawY, drawZ);
                Matrix4x4 matrix = default(Matrix4x4);
                matrix.SetTRS(loc, Quaternion.AngleAxis(angle, Vector3.up), s);
                Graphics.DrawMesh(MeshPool.plane10Back, matrix, matSingle, 0);
            }
        }
Exemple #5
0
        public override void PostAdd(DamageInfo?dinfo)
        {
            base.PostAdd(dinfo);
            List <Hediff> hediffs = this.pawn.health.hediffSet.hediffs;
            Vector2       vector  = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.drawSize;

            initialHediffCount = hediffs.Count;
            Pawn_DrawTracker drawtracker = ((Pawn_DrawTracker)typeof(Pawn).GetField("drawer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(pawn));

            if (drawtracker != null)
            {
                this.pawn_renderer = drawtracker.renderer;
            }
            LongEventHandler.ExecuteWhenFinished(delegate
            {
                if (this.pawn_renderer != null)
                {
                    try
                    {
                        Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>("Things/Pawn/Animal/AA_ArcticLion/AA_ArcticLion_Invisible", ShaderDatabase.Cutout, vector, Color.white);
                        this.pawn_renderer.graphics.ResolveAllGraphics();
                        this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                        (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                    }
                    catch (NullReferenceException) { }
                }
            });
        }
        //RenderPawnAt_PostFix
        // Verse.PawnRenderer
        public static void DrawAt_PostFix(Pawn_DrawTracker __instance, Vector3 loc)
        {
            var pawn = (Pawn)AccessTools.Field(typeof(Pawn_DrawTracker), "pawn").GetValue(__instance);

            if (!(pawn?.GetComp <CompTransmogrified>() is CompTransmogrified {
                IsTransmogrified : true
            } compTrans) ||
                !pawn.Spawned)
            {
                return;
            }

            var matSingle = CultsDefOf.Cults_TransmogAura.graphicData.Graphic.MatSingle;
            var angle     = pawn.Rotation.AsAngle + (compTrans.Hediff.UndulationTicks * 100);

            var xCap = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.x + 0.5f;
            var zCap = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.y + 0.5f;

            var x     = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.x;
            var z     = pawn.kindDef.lifeStages[0].bodyGraphicData.drawSize.y;
            var drawX = Mathf.Clamp((x + compTrans.Hediff.UndulationTicks) * compTrans.Hediff.graphicDiv, 0.01f,
                                    xCap);
            var drawY = AltitudeLayer.Terrain.AltitudeFor();
            var drawZ = Mathf.Clamp((z + compTrans.Hediff.UndulationTicks) * compTrans.Hediff.graphicDiv, 0.01f,
                                    zCap);
            var       s      = new Vector3(drawX, drawY, drawZ);
            Matrix4x4 matrix = default;

            matrix.SetTRS(loc, Quaternion.AngleAxis(angle, Vector3.up), s);
            Graphics.DrawMesh(MeshPool.plane10Back, matrix, matSingle, 0);
        }
        static void Postfix(Pawn_DrawTracker __instance)
        {
            var zombieLeaner = __instance.leaner as ZombieLeaner;

            if (zombieLeaner != null)
            {
                zombieLeaner.ZombieTick();
            }
        }
        static void Postfix(Pawn_DrawTracker __instance, ref Vector3 __result)
        {
            var zombieLeaner = __instance.leaner as ZombieLeaner;

            if (zombieLeaner != null)
            {
                __result += zombieLeaner.ZombieOffset;
            }
        }
        public override void PostSpawnSetup(bool respawningAfterLoad)
        {
            base.PostSpawnSetup(respawningAfterLoad);
            Pawn pawn = this.parent as Pawn;

            animalProductComp = this.parent.TryGetComp <CompAnimalProduct>();
            Pawn_DrawTracker drawtracker = ((Pawn_DrawTracker)typeof(Pawn).GetField("drawer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(pawn));

            if (drawtracker != null)
            {
                this.pawn_renderer = drawtracker.renderer;
            }
            GraphicData dessicatedgraphicdata = new GraphicData();

            dessicatedgraphicdata.texPath = Props.dessicatedTxt;
            dessicatedGraphic             = dessicatedgraphicdata.Graphic;
            this.ChangeTheGraphics();
        }
        static void Postfix(Pawn_DrawTracker __instance, ref Vector3 __result)
        {
            Vector3             drawLoc = __result;
            Pawn                pawn    = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
            ExtendedDataStorage store   = Base.Instance.GetExtendedDataStorage();

            if (store == null)
            {
                return;
            }
            ExtendedPawnData pawnData = store.GetExtendedDataFor(pawn);

            if (pawnData != null && pawnData.mount != null)
            {
                drawLoc = pawnData.mount.Drawer.DrawPos;

                if (pawnData.drawOffset != -1)
                {
                    drawLoc.z = pawnData.mount.Drawer.DrawPos.z + pawnData.drawOffset;
                }
                if (pawnData.mount.def.HasModExtension <DrawingOffsetPatch>())
                {
                    drawLoc += AddCustomOffsets(pawn, pawnData);
                }
                if (pawn.Rotation == Rot4.South)
                {
                    AnimalRecord value;
                    bool         found = Base.drawSelecter.Value.InnerList.TryGetValue(pawnData.mount.def.defName, out value);
                    if (found && value.isSelected)
                    {
                        drawLoc.y = pawnData.mount.Drawer.DrawPos.y - 1;
                    }
                }
                __result = drawLoc;
                if (Base.facialStuffLoaded)
                {
                    __result.y += 0.1f;
                }
            }
            //if (IsMountableUtility.IsCurrentlyMounted(pawn))
            //{
            //  __result.y -= 5;
            //}
        }
Exemple #11
0
        static void Postfix(Pawn_DrawTracker __instance, ref Vector3 __result, ref Pawn ___pawn)
        {
            ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();

            if (store == null)
            {
                return;
            }

            ExtendedPawnData pawnData = store.GetExtendedDataFor(___pawn);

            if (pawnData != null && pawnData.mount != null)
            {
                __result += pawnData.drawOffsetCache;
            }
            else if (pawnData != null)
            {
                pawnData.drawOffsetCache = Vector3.zero;
            }
        }
Exemple #12
0
 public void ResolveCycledGraphic()
 {
     if (Props.cycledGraphic != null)
     {
         Pawn_DrawTracker pawnDrawTracker = lumberer.Drawer;
         if (pawnDrawTracker != null)
         {
             PawnRenderer pawnRenderer = pawnDrawTracker.renderer;
             if (pawnRenderer != null)
             {
                 PawnGraphicSet pawnGraphicSet = pawnRenderer.graphics;
                 if (pawnGraphicSet != null)
                 {
                     pawnGraphicSet.ClearCache();
                     pawnGraphicSet.nakedGraphic = Props.cycledGraphic.Graphic;
                 }
             }
         }
     }
 }
Exemple #13
0
 public void ResolveBaseGraphic()
 {
     if (Props.cycledGraphic != null)
     {
         Pawn_DrawTracker pawnDrawTracker = lumberer.Drawer;
         if (pawnDrawTracker != null)
         {
             PawnRenderer pawnRenderer = pawnDrawTracker.renderer;
             if (pawnRenderer != null)
             {
                 PawnGraphicSet pawnGraphicSet = pawnRenderer.graphics;
                 if (pawnGraphicSet != null)
                 {
                     pawnGraphicSet.ClearCache();
                     //Duplicated code from -> Verse.PawnGrapic -> ResolveAllGraphics
                     PawnKindLifeStage curKindLifeStage = lumberer.ageTracker.CurKindLifeStage;
                     if (lumberer.gender != Gender.Female || curKindLifeStage.femaleGraphicData == null)
                     {
                         pawnGraphicSet.nakedGraphic = curKindLifeStage.bodyGraphicData.Graphic;
                     }
                     else
                     {
                         pawnGraphicSet.nakedGraphic = curKindLifeStage.femaleGraphicData.Graphic;
                     }
                     pawnGraphicSet.rottingGraphic = pawnGraphicSet.nakedGraphic.GetColoredVersion(ShaderDatabase.CutoutSkin, PawnGraphicSet.RottingColor, PawnGraphicSet.RottingColor);
                     if (lumberer.RaceProps.packAnimal)
                     {
                         pawnGraphicSet.packGraphic = GraphicDatabase.Get <Graphic_Multi>(pawnGraphicSet.nakedGraphic.path + "Pack", ShaderDatabase.Cutout, pawnGraphicSet.nakedGraphic.drawSize, Color.white);
                     }
                     if (curKindLifeStage.dessicatedBodyGraphicData != null)
                     {
                         pawnGraphicSet.dessicatedGraphic = curKindLifeStage.dessicatedBodyGraphicData.GraphicColoredFor(lumberer);
                     }
                     //pawnRenderer.RenderPawnAt(lumberer.Position.ToVector3());
                 }
             }
         }
     }
 }
        public void ChangeTheGraphics()
        {
            string currentName = "";

            if (this.parent.Map != null && AnimalBehaviours_Settings.flagGraphicChanging)
            {
                Pawn pawn = this.parent as Pawn;
                if (this.pawn_renderer == null)
                {
                    Pawn_DrawTracker drawtracker = ((Pawn_DrawTracker)typeof(Pawn).GetField("drawer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(pawn));
                    if (drawtracker != null)
                    {
                        this.pawn_renderer = drawtracker.renderer;
                    }
                }

                Vector2 vector = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.drawSize;
                if (Props.waterOverride && this.parent.Position.GetTerrain(this.parent.Map).IsWater)
                {
                    currentName = "Water";
                    if (this.terrainName != currentName)
                    {
                        LongEventHandler.ExecuteWhenFinished(delegate
                        {
                            if (this.pawn_renderer != null)
                            {
                                try
                                {
                                    Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath + Props.waterSuffix, ShaderDatabase.Cutout, vector, Color.white);
                                    this.pawn_renderer.graphics.dessicatedGraphic = dessicatedGraphic;
                                    this.pawn_renderer.graphics.ResolveAllGraphics();
                                    this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                                    (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                                    this.terrainName = pawn.Position.GetTerrain(pawn.Map).defName;
                                    RemoveHediffs(pawn);
                                    if (Props.waterHediffToApply != "")
                                    {
                                        pawn.health.AddHediff(DefDatabase <HediffDef> .GetNamed(Props.waterHediffToApply));
                                    }
                                    if (Props.provideSeasonalItems && animalProductComp != null)
                                    {
                                        animalProductComp.seasonalItemIndex = Props.waterSeasonalItemsIndex;
                                    }
                                }
                                catch (NullReferenceException) { }
                            }
                        });
                    }
                }
                else
                if (Props.lowTemperatureOverride && this.parent.Map.mapTemperature.OutdoorTemp < Props.temperatureThreshold)
                {
                    currentName = "Cold";
                    if (this.terrainName != currentName)
                    {
                        LongEventHandler.ExecuteWhenFinished(delegate
                        {
                            if (this.pawn_renderer != null)
                            {
                                try
                                {
                                    Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath + Props.lowTemperatureSuffix, ShaderDatabase.Cutout, vector, Color.white);
                                    this.pawn_renderer.graphics.dessicatedGraphic = dessicatedGraphic;
                                    this.pawn_renderer.graphics.ResolveAllGraphics();
                                    this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                                    (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                                    this.terrainName = pawn.Position.GetTerrain(pawn.Map).defName;
                                    RemoveHediffs(pawn);
                                    if (Props.lowTemperatureHediffToApply != "")
                                    {
                                        pawn.health.AddHediff(DefDatabase <HediffDef> .GetNamed(Props.lowTemperatureHediffToApply));
                                    }
                                    if (Props.provideSeasonalItems && animalProductComp != null)
                                    {
                                        animalProductComp.seasonalItemIndex = Props.lowTemperatureSeasonalItemsIndex;
                                    }
                                }
                                catch (NullReferenceException) { }
                            }
                        });
                    }
                }
                else if (Props.snowOverride && this.parent.Position.GetSnowDepth(this.parent.Map) > 0)
                {
                    currentName = "Snowy";
                    if (this.terrainName != currentName)
                    {
                        LongEventHandler.ExecuteWhenFinished(delegate
                        {
                            if (this.pawn_renderer != null)
                            {
                                try
                                {
                                    Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath + Props.snowySuffix, ShaderDatabase.Cutout, vector, Color.white);
                                    this.pawn_renderer.graphics.dessicatedGraphic = dessicatedGraphic;
                                    this.pawn_renderer.graphics.ResolveAllGraphics();
                                    this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                                    (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                                    this.terrainName = pawn.Position.GetTerrain(pawn.Map).defName;
                                    RemoveHediffs(pawn);
                                    if (Props.snowyHediffToApply != "")
                                    {
                                        pawn.health.AddHediff(DefDatabase <HediffDef> .GetNamed(Props.snowyHediffToApply));
                                    }
                                    if (Props.provideSeasonalItems && animalProductComp != null)
                                    {
                                        animalProductComp.seasonalItemIndex = Props.snowySeasonalItemsIndex;
                                    }
                                }
                                catch (NullReferenceException) { }
                            }
                        });
                    }
                }
                else



                if (Props.terrains.Contains(pawn.Position.GetTerrain(pawn.Map).defName))
                {
                    int indexTerrain = Props.terrains.IndexOf(pawn.Position.GetTerrain(pawn.Map).defName);

                    currentName = pawn.Position.GetTerrain(pawn.Map).defName;
                    if (this.terrainName != currentName)
                    {
                        LongEventHandler.ExecuteWhenFinished(delegate
                        {
                            if (this.pawn_renderer != null)
                            {
                                try
                                {
                                    Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath + Props.suffix[indexTerrain], ShaderDatabase.Cutout, vector, Color.white);
                                    this.pawn_renderer.graphics.dessicatedGraphic = dessicatedGraphic;
                                    this.pawn_renderer.graphics.ResolveAllGraphics();
                                    this.pawn_renderer.graphics.nakedGraphic = nakedGraphic;
                                    (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                                    this.terrainName = pawn.Position.GetTerrain(pawn.Map).defName;
                                    RemoveHediffs(pawn);
                                    if (Props.hediffToApply != null)
                                    {
                                        pawn.health.AddHediff(DefDatabase <HediffDef> .GetNamed(Props.hediffToApply[indexTerrain]));
                                    }
                                    if (Props.provideSeasonalItems && animalProductComp != null)
                                    {
                                        animalProductComp.seasonalItemIndex = Props.seasonalItemsIndexes[indexTerrain];
                                    }
                                }
                                catch (NullReferenceException) { }
                            }
                        });
                    }
                }
                else
                {
                    currentName = "Normal";
                    if (this.terrainName != currentName)
                    {
                        LongEventHandler.ExecuteWhenFinished(delegate
                        {
                            if (this.pawn_renderer != null)
                            {
                                try
                                {
                                    Graphic_Multi nakedGraphic = (Graphic_Multi)GraphicDatabase.Get <Graphic_Multi>(pawn.ageTracker.CurKindLifeStage.bodyGraphicData.texPath, ShaderDatabase.Cutout, vector, Color.white);
                                    this.pawn_renderer.graphics.nakedGraphic      = nakedGraphic;
                                    this.pawn_renderer.graphics.dessicatedGraphic = dessicatedGraphic;
                                    this.pawn_renderer.graphics.ResolveAllGraphics();
                                    (this.pawn_renderer.graphics.nakedGraphic.data = new GraphicData()).shadowData = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.shadowData;
                                    this.terrainName = "Normal";
                                    RemoveHediffs(pawn);
                                    if (Props.provideSeasonalItems && animalProductComp != null)
                                    {
                                        animalProductComp.seasonalItemIndex = 0;
                                    }
                                }
                                catch (NullReferenceException) { }
                            }
                        });
                    }
                }
            }
        }