Esempio n. 1
0
 static void Postfix(UnitObjInfo objInfo)
 {
     if (!enabled)
     {
         return;
     }
     Singleton <TaskRunner> .Instance.RunDelayTask(0.005f, true, delegate()
     {
         RefreshOneWorkshopLight(objInfo.go);
     });
 }
Esempio n. 2
0
        private static void FixWorkshopTextures()
        {
            LayeredRegion layeredRegion = (LayeredRegion)typeof(FarmModule).GetField("layeredRegion", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <FarmModule> .Self);
            Region        itemLayer     = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);
            List <object> slots         = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots");

            foreach (object slot in slots)
            {
                UnitObjInfo unitObjInfo = (UnitObjInfo)slot.GetType().GetField("unitObjInfo").GetValue(slot);
                GameObject  go          = unitObjInfo.go;
                FixOneTexture(go);
            }
        }
            static void Postfix(RegionViewer __instance, UnitObjInfo objInfo)
            {
                if (!enabled || Module <ScenarioModule> .Self.CurrentScenarioName != "Main" || !(__instance is FarmViewer))
                {
                    return;
                }
                Vector3 pos = objInfo.go.transform.position;

                pos = GetValidPos(pos);
                if (pos != Vector3.zero)
                {
                    objInfo.go.transform.position = pos;
                }
            }
Esempio n. 4
0
        private static void FixHomeTextures()
        {
            Dictionary <string, LayeredRegion> layeredRegions = (Dictionary <string, LayeredRegion>) typeof(WallModule).GetField("walls", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <WallModule> .Self);

            foreach (LayeredRegion layeredRegion in layeredRegions.Values)
            {
                Region        itemLayer = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);
                List <object> slots     = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots");

                foreach (object slot in slots)
                {
                    UnitObjInfo unitObjInfo = (UnitObjInfo)slot.GetType().GetField("unitObjInfo").GetValue(slot);
                    GameObject  go          = unitObjInfo.go;
                    FixOneTexture(go);
                }
            }
        }
Esempio n. 5
0
        private static void RefreshAllLights(Scene scene)
        {
            Dbgl($"Refreshing Lights");
            LayeredRegion layeredRegion = (LayeredRegion)typeof(FarmModule).GetField("layeredRegion", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <FarmModule> .Self);

            if (layeredRegion == null)
            {
                Dbgl("layeredRegion  is null");
                return;
            }
            Region itemLayer = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);

            if (itemLayer == null)
            {
                Dbgl("itemLayer  is null");
                return;
            }
            List <object> slots = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots");

            if (slots == null)
            {
                Dbgl("slots is null");
                return;
            }
            if (settings.customStreetlightLights)
            {
                GameObject[] gameObjects = scene.GetRootGameObjects();
                foreach (GameObject obj in gameObjects)
                {
                    RefreshOneStreetLight(obj);
                }
            }
            foreach (object slot in slots)
            {
                UnitObjInfo unitObjInfo = (UnitObjInfo)slot?.GetType().GetField("unitObjInfo").GetValue(slot);
                GameObject  go          = unitObjInfo?.go;
                if (go?.GetComponentInChildren <Light>() != null)
                {
                    RefreshOneWorkshopLight(go);
                }
            }
        }
Esempio n. 6
0
        private static void DumpObjectNames()
        {
            Scene scene = SceneManager.GetActiveScene();

            if (scene == null)
            {
                Dbgl("scene is null");
                return;
            }
            string        names        = "";
            List <string> meshTextures = new List <string>();

            if (Module <Player> .Self != null && Module <Player> .Self.actor != null)
            {
                GameObject player = Module <Player> .Self.actor.gameObject;
                names += $"Player actor mesh and texture names:\r\n\r\n\t";


                MeshRenderer[] mrs = player.GetComponentsInChildren <MeshRenderer>();

                foreach (MeshRenderer mr in mrs)
                {
                    if (mr.materials?.Length > 1)
                    {
                        for (int i = 0; i < mr.materials.Length; i++)
                        {
                            if (mr.materials[i] && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                            {
                                string mt = $"mesh name: {mr.name} material {i} texture name: {mr.materials[i].mainTexture.name}";
                                if (!meshTextures.Contains(mt))
                                {
                                    meshTextures.Add(mt);
                                }
                            }
                        }
                    }
                    else if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                    {
                        string mt = $"mesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                        if (!meshTextures.Contains(mt))
                        {
                            meshTextures.Add(mt);
                        }
                    }
                }

                SkinnedMeshRenderer[] smrs = player.GetComponentsInChildren <SkinnedMeshRenderer>();

                foreach (SkinnedMeshRenderer mr in smrs)
                {
                    if (mr.materials?.Length > 1)
                    {
                        for (int i = 0; i < mr.materials.Length; i++)
                        {
                            if (mr.materials[i] && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                            {
                                string mt = $"mesh name: {mr.name} material {i} texture name: {mr.materials[i].mainTexture.name}";
                                if (!meshTextures.Contains(mt))
                                {
                                    meshTextures.Add(mt);
                                }
                            }
                        }
                    }
                    else if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                    {
                        string mt = $"smesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                        if (!meshTextures.Contains(mt))
                        {
                            meshTextures.Add(mt);
                        }
                    }
                }

                BlinkController bc = (BlinkController)typeof(Actor).GetField("blinkController", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <Player> .Self.actor);
                if (bc != null)
                {
                    SkinnedMeshRenderer smr = (SkinnedMeshRenderer)typeof(BlinkController).GetField("_mesh", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(bc);
                    if (smr != null && smr.material && smr.material.HasProperty("_MainTex") && smr.material.mainTexture != null)
                    {
                        string mt = $"blink mesh name: {smr.name} texture name: {smr.material.mainTexture.name}";
                        if (!meshTextures.Contains(mt))
                        {
                            meshTextures.Add(mt);
                        }
                    }
                }

                names += string.Join("\r\n\t", meshTextures.ToArray()) + "\r\n\r\n";
                meshTextures.Clear();
            }

            names += $"DLC actor mesh and texture names:\r\n\r\n\t";

            List <AppearDBData> list = DbReader.Read <AppearDBData>(LocalDb.cur.ReadFullTable("NPCAppear_List"), 20);

            foreach (AppearDBData data in list)
            {
                string        path = data.appearPath;
                NpcAppearUnit unit = Singleton <ResMgr> .Instance.LoadSyncByType <NpcAppearUnit>(AssetType.NpcAppear, path);

                foreach (SkinnedMeshRenderer mr in unit.smrs)
                {
                    if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                    {
                        string mt = $"mesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                        if (!meshTextures.Contains(mt))
                        {
                            meshTextures.Add(mt);
                        }
                    }
                }
            }

            names += string.Join("\r\n\t", meshTextures.ToArray()) + "\r\n\r\n";
            meshTextures.Clear();

            Dbgl("got dlc actor meshes");

            /*
             * names += $"Non-DLC actor mesh and texture names for scene {scene.name}:\r\n\r\n";
             *
             * Module<ActorMgr>.Self.Foreach(delegate (Actor actor) {
             *  if (actor.SceneName == scene.name && actor.GetComponent<NpcAppear>() == null)
             *  {
             *      GameObject go = actor.modelRoot.transform.parent.gameObject;
             *      SkinnedMeshRenderer[] smrs = go.GetComponentsInChildren<SkinnedMeshRenderer>();
             *      foreach (SkinnedMeshRenderer mr in smrs)
             *      {
             *          if (mr.material && mr.material.HasProperty("_MainTex"))
             *          {
             *              names += $"\tmesh name: {mr.name} texture name: {mr.material.mainTexture.name}\r\n";
             *          }
             *      }
             *  }
             * });
             * names += $"\r\n\r\n";
             */
            GameObject[] gameObjects = scene.GetRootGameObjects();
            foreach (GameObject obj in gameObjects)
            {
                MeshRenderer[] mrs = obj.GetComponentsInChildren <MeshRenderer>();
                foreach (MeshRenderer mr in mrs)
                {
                    if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                    {
                        string mt = $"mesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                        if (!meshTextures.Contains(mt))
                        {
                            meshTextures.Add(mt);
                        }
                    }
                }
            }


            Dbgl("got scene objects");


            if (scene.name == "Main")
            {
                LayeredRegion layeredRegion = (LayeredRegion)typeof(FarmModule).GetField("layeredRegion", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <FarmModule> .Self);
                Region        itemLayer     = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);
                List <object> slots         = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots");

                foreach (object slot in slots)
                {
                    UnitObjInfo unitObjInfo = (UnitObjInfo)slot.GetType().GetField("unitObjInfo").GetValue(slot);
                    GameObject  go          = unitObjInfo.go;
                    if (go == null)
                    {
                        break;
                    }
                    MeshRenderer[] mrs = go.GetComponentsInChildren <MeshRenderer>();
                    foreach (MeshRenderer mr in mrs)
                    {
                        if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                        {
                            string mt = $"mesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                            if (!meshTextures.Contains(mt))
                            {
                                meshTextures.Add(mt);
                            }
                        }
                    }
                }
            }
            else if (scene.name == "PlayerHome")
            {
                Dictionary <string, LayeredRegion> layeredRegions = (Dictionary <string, LayeredRegion>) typeof(WallModule).GetField("walls", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <WallModule> .Self);

                foreach (LayeredRegion layeredRegion in layeredRegions.Values)
                {
                    Region        itemLayer = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);
                    List <object> slots     = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots");

                    foreach (object slot in slots)
                    {
                        UnitObjInfo unitObjInfo = (UnitObjInfo)slot.GetType().GetField("unitObjInfo").GetValue(slot);
                        GameObject  go          = unitObjInfo.go;
                        if (go == null)
                        {
                            break;
                        }
                        MeshRenderer[] mrs = go.GetComponentsInChildren <MeshRenderer>();
                        foreach (MeshRenderer mr in mrs)
                        {
                            if (mr.material && mr.material.HasProperty("_MainTex") && mr.material.mainTexture != null)
                            {
                                string mt = $"mesh name: {mr.name} texture name: {mr.material.mainTexture.name}";
                                if (!meshTextures.Contains(mt))
                                {
                                    meshTextures.Add(mt);
                                }
                            }
                        }
                    }
                }
            }
            names += $"Scene mesh and texture names for scene {scene.name}:\r\n\r\n\t" + string.Join("\r\n\t", meshTextures.ToArray());
            Debug.Log(names);
        }