make it buildable

PrashantMohta · PrashantMohta · commit 1a7cd45430cf · 2025-05-17T09:13:43.000+07:00
diff --git a/CustomKnight/NewUI/UIController.cs b/CustomKnight/NewUI/UIController.cs
@@ -1,4 +1,7 @@
-﻿using UnityEngine.UI;
+﻿using System.Linq;
+using CustomKnight.Next.Skin;
+using CustomKnight.Next.Skin.Enum;
+using UnityEngine.UI;
 
 namespace CustomKnight.NewUI
 {
@@ -134,42 +137,17 @@ public static void showMenu()
             UI.SetActive(true);
         }
 
-        public static Texture2D GetSkinIcon(ISelectableSkin skin)
+        public static Texture2D GetSkinIcon(ISkin skin)
         {
-            var orbIcon = "orbicon.png";
-            var orbFull = "OrbFull.png";
-            var knight = "knight.png";
-            if (skin.Exists(orbIcon))
+            var hasIcon = skin.GetFeatures().Contains(Feature.Icon);
+            if (hasIcon)
             {
-                return skin.GetTexture(orbIcon);
+                return skin.GetIcon();
             }
-            Texture2D defaultOrb = Texture2D.blackTexture;
-
-            if (skin.Exists(knight))
-            {
-                var defaultSkin = SkinManager.GetDefaultSkin();
-                if (skin.Exists(orbFull))
-                {
-                    defaultOrb = skin.GetTexture(orbFull);
-                }
-                else if (defaultSkin.Exists(orbFull))
-                {
-                    defaultOrb = defaultSkin.GetTexture(orbFull);
-                }
-                var tex = skin.GetTexture(knight).GetCropped(new Rect(2802f, 4096f - 3155f, 86f, 120f));
-                if (defaultOrb != Texture2D.blackTexture)
-                {
-                    tex = SheetItem.Overlay(defaultOrb, tex, 50, 65);
-                }
-                DefaultSkin.Save(tex, skin.GetId(), orbIcon, false);
-                return tex;
-            }
-
-            //should never happen but still
-            return defaultOrb;
+            return Texture2D.blackTexture;
         }
 
-        public static void ApplySkin(ISelectableSkin skin)
+        public static void ApplySkin(ISkin skin)
         {
             UIManager.instance.TogglePauseGame();
             CustomKnight.GlobalSettings.AddRecentSkin(skin.GetId());
diff --git a/CustomKnight/Next/Migrations/GenerateSkinIconMigration.cs b/CustomKnight/Next/Migrations/GenerateSkinIconMigration.cs
@@ -0,0 +1,43 @@
+﻿using System.IO;
+using CustomKnight.Next.Skin;
+
+namespace CustomKnight.Next.Migrations
+{
+    internal class GenerateSkinIconMigration : BaseMigration
+    {
+        public override void Run(MigrationContext context)
+        {
+
+            var knightPath = Path.Combine(context.SkinPath, "knight", "knight.png");
+            var orbFull = Path.Combine("ui","orbfull.png");
+            var orbIcon = Path.Combine("ui", "orbicon.png");
+            var OrbfullPath = Path.Combine(context.SkinPath, orbFull);
+            var OrbIconPath = Path.Combine(context.SkinPath, orbIcon);
+            if (File.Exists(OrbIconPath))
+            {
+                return;
+            }
+            Texture2D defaultOrb = Texture2D.blackTexture;
+
+            if (File.Exists(knightPath))
+            {
+                var defaultSkin = SkinManager.GetDefaultSkin();
+                if (File.Exists(OrbfullPath))
+                {
+                    defaultOrb = TextureUtils.LoadTextureFromFile(OrbfullPath);
+                }
+                else if (DefaultSkin.Exists(orbFull))
+                {
+                    defaultOrb = DefaultSkin.GetTexture(orbFull);
+                }
+                var tex = TextureUtils.LoadTextureFromFile(knightPath).GetCropped(new Rect(2802f, 4096f - 3155f, 86f, 120f));
+                if (defaultOrb != Texture2D.blackTexture)
+                {
+                    tex = SheetItem.Overlay(defaultOrb, tex, 50, 65);
+                }
+                DefaultSkin.Save(tex, context.SkinName, orbIcon, false);
+            }
+
+        }
+    }
+}
diff --git a/CustomKnight/Next/Migrations/MigrationManager.cs b/CustomKnight/Next/Migrations/MigrationManager.cs
@@ -7,6 +7,7 @@ static class MigrationManager
             new CharmMigration(),
             new GroupMigration(),
             new GenerateSaveHudMigration(),
+            new GenerateSkinIconMigration(),
             new KnownSwapIntegrationMigration(),
             new MigrateDirectorySwapsToNames(),
             new GenerateManifestMigration(),
diff --git a/CustomKnight/Next/Skin/Enum/Feature.cs b/CustomKnight/Next/Skin/Enum/Feature.cs
@@ -9,6 +9,7 @@ public enum Feature
         Cinematics,
         SaveSelection,
         UserInterface,
-        MainMenu
+        MainMenu,
+        Icon
     }
 }
diff --git a/CustomKnight/Next/Skin/Skin.cs b/CustomKnight/Next/Skin/Skin.cs
@@ -32,6 +32,6 @@ public interface ISkin
         /// </summary>
         /// <returns>A <c>ItemGroup</c>> representing all the item groups in the skin</returns>
         public abstract ItemGroup[] GetGroups();
-
+        Texture2D GetIcon();
     }
 }
diff --git a/CustomKnight/Skin/Base/Skin/StaticSkin.cs b/CustomKnight/Skin/Base/Skin/StaticSkin.cs
@@ -34,6 +34,11 @@ public StaticSkin(string DirectoryName)
         public SkinSettings GetSettings() => skinSettings;
         public ItemGroup[] GetGroups() => [.. items];
 
+        public Texture2D GetIcon()
+        {
+            throw new NotImplementedException();
+        }
+
         // might yeet all of these afterwards
         public bool shouldCache() => ShouldCache();
         public bool hasSwapper() => true;
diff --git a/CustomKnight/Skin/Base/SkinManager.cs b/CustomKnight/Skin/Base/SkinManager.cs
@@ -9,7 +9,7 @@ namespace CustomKnight
     /// </summary>
     public static class SkinManager
     {
-        internal static string DEFAULT_SKIN = "Default";
+        internal static string DEFAULT_SKIN = "default";
         internal static bool savedDefaultTextures = false;
         /// <summary>
         /// Name of the Data directory
diff --git a/CustomKnight/Skin/Base/SpriteLoader.cs b/CustomKnight/Skin/Base/SpriteLoader.cs
@@ -1,4 +1,6 @@
-﻿namespace CustomKnight
+﻿using CustomKnight.Next.Skin;
+
+namespace CustomKnight
 {
     internal class SpriteLoader
     {
@@ -95,18 +97,22 @@ internal static void LoadSprites()
                     texture.missing = cachedTex.missing;
                     continue;
                 }
-                texture.missing = !SkinManager.CurrentSkin.Exists(texture.fileName);
-                if (!texture.missing)
+                var currentSkin = SkinManager.CurrentSkin;
+                if(currentSkin is ISelectableSkin deprecatedSkin)
                 {
-                    texture.tex = SkinManager.CurrentSkin.GetTexture(texture.fileName);
-                    if (SkinManager.CurrentSkin.ShouldCache())
+                    texture.missing = !deprecatedSkin.Exists(texture.fileName);
+                    if (!texture.missing)
                     {
-                        TextureCache.setSkinTextureCache(SkinManager.CurrentSkin.GetId(), texture.fileName, new CustomKnightTexture(texture.fileName, texture.missing, texture.defaultTex, texture.tex));
+                        texture.tex = deprecatedSkin.GetTexture(texture.fileName);
+                        if (currentSkin.ShouldCache())
+                        {
+                            TextureCache.setSkinTextureCache(deprecatedSkin.GetId(), texture.fileName, new CustomKnightTexture(texture.fileName, texture.missing, texture.defaultTex, texture.tex));
+                        }
+                    }
+                    else
+                    {
+                        texture.tex = null;
                     }
-                }
-                else
-                {
-                    texture.tex = null;
                 }
             }
             TextureCache.trimTextureCache();
diff --git a/CustomKnight/Skin/Cinematics/CinematicsManager.cs b/CustomKnight/Skin/Cinematics/CinematicsManager.cs
@@ -63,12 +63,6 @@ private static bool GetCiematicSafely(string name, out Cinematic cinematic)
         }
 
 
-        public static bool HasCinematic(string CinematicName)
-        {
-            var cinematicUrl = GetCinematicUrl(CinematicName);
-            return cinematicUrl.Length > 0;
-        }
-
         private static void XB1CinematicVideoPlayer_ctor(On.XB1CinematicVideoPlayer.orig_ctor orig, XB1CinematicVideoPlayer self, CinematicVideoPlayerConfig config)
         {
             orig(self, config);
@@ -80,60 +74,49 @@ private static void XB1CinematicVideoPlayer_ctor(On.XB1CinematicVideoPlayer.orig
                     if (cinematicKvp.Value.OriginalVideo != null && (cinematicKvp.Value.OriginalVideo.originalPath == source.clip.originalPath))
                     {
                         cinematicKvp.Value.player = self;
-                        if (SkinManager.GetCurrentSkin().HasCinematic(cinematicKvp.Value.ClipName))
-                        {
-                            source.clip = null;
-                            source.url = SkinManager.GetCurrentSkin().GetCinematicUrl(cinematicKvp.Value.ClipName);
-                            source.Prepare();
-                        }
-                        else if (HasCinematic(cinematicKvp.Value.ClipName))
+                        var skin = SkinManager.GetCurrentSkin();
+                        if(skin is ISelectableSkin deprecatedSkin)
                         {
-                            source.clip = null;
-                            source.url = GetCinematicUrl(cinematicKvp.Value.ClipName);
-                            source.Prepare();
+
+                            if (deprecatedSkin.HasCinematic(cinematicKvp.Value.ClipName))
+                            {
+                                source.clip = null;
+                                source.url = deprecatedSkin.GetCinematicUrl(cinematicKvp.Value.ClipName);
+                                source.Prepare();
+                            }
                         }
                     }
                 }
             }
         }
 
-
-        public static string GetCinematicUrl(string CinematicName)
-        {
-            EnsureDirectory($"{SkinManager.DATA_DIR}/Cinematics/");
-            string path = "";
-            string file = ($"{SkinManager.DATA_DIR}/Cinematics/{CinematicName}").Replace("\\", "/");
-            if (File.Exists(file + ".webm"))
-            {
-                path = file + ".webm";
-            }
-            CustomKnight.Instance.LogFine("[GetCinematicUrl]" + CinematicName + ":" + path);
-            return path;
-        }
-
         private static void CinematicSequence_Update(On.CinematicSequence.orig_Update orig, CinematicSequence self)
         {
             var fles = new CinematicSequenceR(self);
             if (GetCiematicSafely(fles.videoReference.VideoFileName, out var cinematic))
             {
-                if (SkinManager.GetCurrentSkin().HasCinematic(cinematic.ClipName) || HasCinematic(cinematic.ClipName))
+                var skin = SkinManager.GetCurrentSkin();
+                if (skin is ISelectableSkin deprecatedSkin)
                 {
-                    if (cinematic.player != null)
+                    if (deprecatedSkin.HasCinematic(cinematic.ClipName))
                     {
-                        VideoPlayer source = ReflectionHelper.GetField<XB1CinematicVideoPlayer, VideoPlayer>(cinematic.player, "videoPlayer"); ;
-                        if ((ulong)source.frame < source.frameCount - 1)
+                        if (cinematic.player != null)
                         {
-                            fles.framesSinceBegan = 0;
+                            VideoPlayer source = ReflectionHelper.GetField<XB1CinematicVideoPlayer, VideoPlayer>(cinematic.player, "videoPlayer"); ;
+                            if ((ulong)source.frame < source.frameCount - 1)
+                            {
+                                fles.framesSinceBegan = 0;
+                            }
+                            else
+                            {
+                                fles.framesSinceBegan = 11;
+                            }
                         }
                         else
                         {
-                            fles.framesSinceBegan = 11;
+                            fles.framesSinceBegan = 0;
                         }
                     }
-                    else
-                    {
-                        fles.framesSinceBegan = 0;
-                    }
                 }
             }
             orig(self);
diff --git a/CustomKnight/Skin/Morph/DefaultSkin.cs b/CustomKnight/Skin/Morph/DefaultSkin.cs
@@ -47,6 +47,18 @@ public static void SaveSkin()
             isGeneratingDefaultSkin = true;
             CoroutineHelper.GetRunner().StartCoroutine(GenerateSkin());
         }
+
+        public static bool Exists(string fileName)
+        {
+            var filePath = Path.Combine(SkinManager.SKINS_FOLDER, SkinManager.DEFAULT_SKIN, fileName);
+            return File.Exists(filePath);
+        }
+
+        public static Texture2D GetTexture(string fileName)
+        {
+            var filePath = Path.Combine(SkinManager.SKINS_FOLDER, SkinManager.DEFAULT_SKIN, fileName);
+            return TextureUtils.LoadTextureFromFile(filePath);
+        }
         public static void Save(Texture2D texture, string skinName, string path, bool overwrite = false)
         {
             var folderPath = Path.Combine(SkinManager.SKINS_FOLDER, skinName);
diff --git a/CustomKnight/Skin/Morph/SaveHud.cs b/CustomKnight/Skin/Morph/SaveHud.cs
@@ -78,8 +78,10 @@ private static void SaveSlotButton_PresentSaveSlot(On.UnityEngine.UI.SaveSlotBut
             
             var currZone = !saveStats.bossRushMode ? saveStats.mapZone.ToString() : MapZone.GODS_GLORY.ToString();
             if (AreaBackgrounds.TryGetValue(currZone, out var mapzone))
-            {
+            {/*
+              * todo redo
                 self.background.sprite = mapzone.Exists(skin) ? mapzone.GetSpriteForSkin(skin) : self.background.sprite;
+                */
             }
         }
 
diff --git a/CustomKnight/Skin/Morph/SheetItem.cs b/CustomKnight/Skin/Morph/SheetItem.cs
@@ -150,12 +150,15 @@ public void Overlay(Texture2D overlaytex, int x, int y)
         public Sprite GetSpriteForSkin(ISkin skin)
         {
             if (cache.TryGetValue(skin.GetId(), out var sprite)) { return sprite; }
-            if (skin.Exists(path))
-            {
-                var tex = skin.GetTexture(path);
-                var pivot = new Vector2(0.5f, 0.5f);
-                cache[skin.GetId()] = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), pivot);
-                return cache[skin.GetId()];
+            if (skin is ISelectableSkin deprecatedSkin) {
+
+                if (deprecatedSkin.Exists(path))
+                {
+                    var tex = deprecatedSkin.GetTexture(path);
+                    var pivot = new Vector2(0.5f, 0.5f);
+                    cache[skin.GetId()] = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), pivot);
+                    return cache[skin.GetId()];
+                }
             }
             return null;
         }

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ public enum Feature`
`9`	`9`	`Cinematics,`
`10`	`10`	`SaveSelection,`
`11`	`11`	`UserInterface,`
`12`		`- MainMenu`
	`12`	`+ MainMenu,`
	`13`	`+ Icon`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,6 @@ public interface ISkin`
`32`	`32`	`/// </summary>`
`33`	`33`	`/// <returns>A <c>ItemGroup</c>> representing all the item groups in the skin</returns>`
`34`	`34`	`public abstract ItemGroup[] GetGroups();`
`35`		`-`
	`35`	`+ Texture2D GetIcon();`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace CustomKnight`
`9`	`9`	`/// </summary>`
`10`	`10`	`public static class SkinManager`
`11`	`11`	`{`
`12`		`- internal static string DEFAULT_SKIN = "Default";`
	`12`	`+ internal static string DEFAULT_SKIN = "default";`
`13`	`13`	`internal static bool savedDefaultTextures = false;`
`14`	`14`	`/// <summary>`
`15`	`15`	`/// Name of the Data directory`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`		`-namespace CustomKnight`
	`1`	`+using CustomKnight.Next.Skin;`
	`2`	`+`
	`3`	`+namespace CustomKnight`
`2`	`4`	`{`
`3`	`5`	`internal class SpriteLoader`
`4`	`6`	`{`
`@@ -95,18 +97,22 @@ internal static void LoadSprites()`
`95`	`97`	`texture.missing = cachedTex.missing;`
`96`	`98`	`continue;`
`97`	`99`	`}`
`98`		`- texture.missing = !SkinManager.CurrentSkin.Exists(texture.fileName);`
`99`		`- if (!texture.missing)`
	`100`	`+ var currentSkin = SkinManager.CurrentSkin;`
	`101`	`+ if(currentSkin is ISelectableSkin deprecatedSkin)`
`100`	`102`	`{`
`101`		`- texture.tex = SkinManager.CurrentSkin.GetTexture(texture.fileName);`
`102`		`- if (SkinManager.CurrentSkin.ShouldCache())`
	`103`	`+ texture.missing = !deprecatedSkin.Exists(texture.fileName);`
	`104`	`+ if (!texture.missing)`
`103`	`105`	`{`
`104`		`- TextureCache.setSkinTextureCache(SkinManager.CurrentSkin.GetId(), texture.fileName, new CustomKnightTexture(texture.fileName, texture.missing, texture.defaultTex, texture.tex));`
	`106`	`+ texture.tex = deprecatedSkin.GetTexture(texture.fileName);`
	`107`	`+ if (currentSkin.ShouldCache())`
	`108`	`+ {`
	`109`	`+ TextureCache.setSkinTextureCache(deprecatedSkin.GetId(), texture.fileName, new CustomKnightTexture(texture.fileName, texture.missing, texture.defaultTex, texture.tex));`
	`110`	`+ }`
	`111`	`+ }`
	`112`	`+ else`
	`113`	`+ {`
	`114`	`+ texture.tex = null;`
`105`	`115`	`}`
`106`		`- }`
`107`		`- else`
`108`		`- {`
`109`		`- texture.tex = null;`
`110`	`116`	`}`
`111`	`117`	`}`
`112`	`118`	`TextureCache.trimTextureCache();`
Original file line number	Diff line number	Diff line change
`@@ -63,12 +63,6 @@ private static bool GetCiematicSafely(string name, out Cinematic cinematic)`
`63`	`63`	`}`
`64`	`64`
`65`	`65`
`66`		`- public static bool HasCinematic(string CinematicName)`
`67`		`- {`
`68`		`- var cinematicUrl = GetCinematicUrl(CinematicName);`
`69`		`- return cinematicUrl.Length > 0;`
`70`		`- }`
`71`		`-`
`72`	`66`	`private static void XB1CinematicVideoPlayer_ctor(On.XB1CinematicVideoPlayer.orig_ctor orig, XB1CinematicVideoPlayer self, CinematicVideoPlayerConfig config)`
`73`	`67`	`{`
`74`	`68`	`orig(self, config);`
`@@ -80,60 +74,49 @@ private static void XB1CinematicVideoPlayer_ctor(On.XB1CinematicVideoPlayer.orig`
`80`	`74`	`if (cinematicKvp.Value.OriginalVideo != null && (cinematicKvp.Value.OriginalVideo.originalPath == source.clip.originalPath))`
`81`	`75`	`{`
`82`	`76`	`cinematicKvp.Value.player = self;`
`83`		`- if (SkinManager.GetCurrentSkin().HasCinematic(cinematicKvp.Value.ClipName))`
`84`		`- {`
`85`		`- source.clip = null;`
`86`		`- source.url = SkinManager.GetCurrentSkin().GetCinematicUrl(cinematicKvp.Value.ClipName);`
`87`		`- source.Prepare();`
`88`		`- }`
`89`		`- else if (HasCinematic(cinematicKvp.Value.ClipName))`
	`77`	`+ var skin = SkinManager.GetCurrentSkin();`
	`78`	`+ if(skin is ISelectableSkin deprecatedSkin)`
`90`	`79`	`{`
`91`		`- source.clip = null;`
`92`		`- source.url = GetCinematicUrl(cinematicKvp.Value.ClipName);`
`93`		`- source.Prepare();`
	`80`	`+`
	`81`	`+ if (deprecatedSkin.HasCinematic(cinematicKvp.Value.ClipName))`
	`82`	`+ {`
	`83`	`+ source.clip = null;`
	`84`	`+ source.url = deprecatedSkin.GetCinematicUrl(cinematicKvp.Value.ClipName);`
	`85`	`+ source.Prepare();`
	`86`	`+ }`
`94`	`87`	`}`
`95`	`88`	`}`
`96`	`89`	`}`
`97`	`90`	`}`
`98`	`91`	`}`
`99`	`92`
`100`		`-`
`101`		`- public static string GetCinematicUrl(string CinematicName)`
`102`		`- {`
`103`		`- EnsureDirectory($"{SkinManager.DATA_DIR}/Cinematics/");`
`104`		`- string path = "";`
`105`		`- string file = ($"{SkinManager.DATA_DIR}/Cinematics/{CinematicName}").Replace("\\", "/");`
`106`		`- if (File.Exists(file + ".webm"))`
`107`		`- {`
`108`		`- path = file + ".webm";`
`109`		`- }`
`110`		`- CustomKnight.Instance.LogFine("[GetCinematicUrl]" + CinematicName + ":" + path);`
`111`		`- return path;`
`112`		`- }`
`113`		`-`
`114`	`93`	`private static void CinematicSequence_Update(On.CinematicSequence.orig_Update orig, CinematicSequence self)`
`115`	`94`	`{`
`116`	`95`	`var fles = new CinematicSequenceR(self);`
`117`	`96`	`if (GetCiematicSafely(fles.videoReference.VideoFileName, out var cinematic))`
`118`	`97`	`{`
`119`		`- if (SkinManager.GetCurrentSkin().HasCinematic(cinematic.ClipName) \|\| HasCinematic(cinematic.ClipName))`
	`98`	`+ var skin = SkinManager.GetCurrentSkin();`
	`99`	`+ if (skin is ISelectableSkin deprecatedSkin)`
`120`	`100`	`{`
`121`		`- if (cinematic.player != null)`
	`101`	`+ if (deprecatedSkin.HasCinematic(cinematic.ClipName))`
`122`	`102`	`{`
`123`		`- VideoPlayer source = ReflectionHelper.GetField<XB1CinematicVideoPlayer, VideoPlayer>(cinematic.player, "videoPlayer"); ;`
`124`		`- if ((ulong)source.frame < source.frameCount - 1)`
	`103`	`+ if (cinematic.player != null)`
`125`	`104`	`{`
`126`		`- fles.framesSinceBegan = 0;`
	`105`	`+ VideoPlayer source = ReflectionHelper.GetField<XB1CinematicVideoPlayer, VideoPlayer>(cinematic.player, "videoPlayer"); ;`
	`106`	`+ if ((ulong)source.frame < source.frameCount - 1)`
	`107`	`+ {`
	`108`	`+ fles.framesSinceBegan = 0;`
	`109`	`+ }`
	`110`	`+ else`
	`111`	`+ {`
	`112`	`+ fles.framesSinceBegan = 11;`
	`113`	`+ }`
`127`	`114`	`}`
`128`	`115`	`else`
`129`	`116`	`{`
`130`		`- fles.framesSinceBegan = 11;`
	`117`	`+ fles.framesSinceBegan = 0;`
`131`	`118`	`}`
`132`	`119`	`}`
`133`		`- else`
`134`		`- {`
`135`		`- fles.framesSinceBegan = 0;`
`136`		`- }`
`137`	`120`	`}`
`138`	`121`	`}`
`139`	`122`	`orig(self);`