using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SwapLogo")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SwapLogo")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d787473a-309b-47e6-97e0-e342266ce9fa")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SwapLogo;
[BepInPlugin("h4nz0.valheim.swaplogo", "Swap Logo", "1.1.0")]
public class SwapLogoPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <>c__DisplayClass33_0
{
public bool attemptSuccess;
internal void <ReplaceLogoDelayed>b__0(bool result)
{
attemptSuccess = result;
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass34_0
{
public Sprite customSprite;
internal void <TryReplaceLogoCoroutine>b__0(Sprite sprite)
{
customSprite = sprite;
}
}
[CompilerGenerated]
private sealed class <FadeInLogoCoroutine>d__40 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Image targetImage;
private float <duration>5__1;
private Color <color>5__2;
private float <elapsed>5__3;
private float <t>5__4;
private float <smooth>5__5;
private Color <newColor>5__6;
private Color <finalColor>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <FadeInLogoCoroutine>d__40(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)targetImage == (Object)null || (Object)(object)((Component)targetImage).gameObject == (Object)null)
{
return false;
}
<duration>5__1 = ((FadeDuration != null) ? Mathf.Max(0.01f, FadeDuration.Value) : 0.8f);
<color>5__2 = ((Graphic)targetImage).color;
<color>5__2.a = 0f;
((Graphic)targetImage).color = <color>5__2;
<elapsed>5__3 = 0f;
break;
case 1:
<>1__state = -1;
break;
}
if (<elapsed>5__3 < <duration>5__1)
{
if ((Object)(object)targetImage == (Object)null || (Object)(object)((Component)targetImage).gameObject == (Object)null)
{
return false;
}
<elapsed>5__3 += Time.unscaledDeltaTime;
<t>5__4 = Mathf.Clamp01(<elapsed>5__3 / <duration>5__1);
<smooth>5__5 = Mathf.SmoothStep(0f, 1f, <t>5__4);
<newColor>5__6 = ((Graphic)targetImage).color;
<newColor>5__6.a = <smooth>5__5;
((Graphic)targetImage).color = <newColor>5__6;
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)targetImage != (Object)null)
{
<finalColor>5__7 = ((Graphic)targetImage).color;
<finalColor>5__7.a = 1f;
((Graphic)targetImage).color = <finalColor>5__7;
}
LogVerbose("[Swap Logo] Áttűnés (fade) animáció kész.");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <LoadSpriteFromFileCoroutine>d__32 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public string filePath;
public Action<Sprite> onLoaded;
private string <url>5__1;
private UnityWebRequest <request>5__2;
private bool <hasError>5__3;
private Texture2D <texture>5__4;
private Rect <rect>5__5;
private Vector2 <pivot>5__6;
private Sprite <sprite>5__7;
private Exception <ex>5__8;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadSpriteFromFileCoroutine>d__32(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<url>5__1 = null;
<request>5__2 = null;
<texture>5__4 = null;
<sprite>5__7 = null;
<ex>5__8 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: Invalid comparison between Unknown and I4
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
bool result;
try
{
switch (<>1__state)
{
default:
result = false;
break;
case 0:
<>1__state = -1;
if (string.IsNullOrWhiteSpace(filePath))
{
LogWarning("[Swap Logo] A logófájl útvonala üres.");
onLoaded?.Invoke(null);
result = false;
break;
}
if (!File.Exists(filePath))
{
LogWarning("[Swap Logo] A logófájl nem található: " + filePath);
onLoaded?.Invoke(null);
result = false;
break;
}
<url>5__1 = "file:///" + filePath.Replace("\\", "/");
LogVerbose("[Swap Logo] Logó betöltése innen: " + <url>5__1);
<request>5__2 = UnityWebRequestTexture.GetTexture(<url>5__1);
<>1__state = -3;
<>2__current = <request>5__2.SendWebRequest();
<>1__state = 1;
result = true;
break;
case 1:
{
<>1__state = -3;
<hasError>5__3 = (int)<request>5__2.result != 1;
if (<hasError>5__3)
{
LogError(string.Format("[{0}] Hiba a logó betöltése közben: {1} | {2}", "Swap Logo", <request>5__2.result, <request>5__2.error));
onLoaded?.Invoke(null);
result = false;
}
else
{
try
{
<texture>5__4 = DownloadHandlerTexture.GetContent(<request>5__2);
if (!((Object)(object)<texture>5__4 == (Object)null))
{
((Object)<texture>5__4).name = "SwapLogoTexture";
((Texture)<texture>5__4).wrapMode = (TextureWrapMode)1;
((Texture)<texture>5__4).filterMode = (FilterMode)1;
<rect>5__5 = new Rect(0f, 0f, (float)((Texture)<texture>5__4).width, (float)((Texture)<texture>5__4).height);
<pivot>5__6 = new Vector2(0.5f, 0.5f);
<sprite>5__7 = Sprite.Create(<texture>5__4, <rect>5__5, <pivot>5__6, 100f);
((Object)<sprite>5__7).name = "SwapLogoSprite";
LogVerbose(string.Format("[{0}] Logó betöltve: {1}x{2}", "Swap Logo", ((Texture)<texture>5__4).width, ((Texture)<texture>5__4).height));
onLoaded?.Invoke(<sprite>5__7);
<texture>5__4 = null;
<sprite>5__7 = null;
goto IL_030f;
}
LogError("[Swap Logo] A textúra betöltése sikertelen, a kapott Texture2D null.");
onLoaded?.Invoke(null);
result = false;
}
catch (Exception ex)
{
<ex>5__8 = ex;
LogError(string.Format("[{0}] Kivétel a textúra vagy sprite létrehozásakor: {1}", "Swap Logo", <ex>5__8));
onLoaded?.Invoke(null);
goto IL_030f;
}
}
<>m__Finally1();
break;
}
IL_030f:
<>m__Finally1();
<request>5__2 = null;
result = false;
break;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
return result;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<request>5__2 != null)
{
((IDisposable)<request>5__2).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ReplaceLogoDelayed>d__33 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private float <initialDelay>5__1;
private int <attempts>5__2;
private float <interval>5__3;
private int <minScore>5__4;
private bool <success>5__5;
private int <i>5__6;
private <>c__DisplayClass33_0 <>8__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReplaceLogoDelayed>d__33(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0237: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Expected O, but got Unknown
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)Instance == (Object)null)
{
return false;
}
if (_replaceRoutineStarted)
{
LogVerbose("[Swap Logo] A logócsere rutin már elindult, új példány nem indul.");
return false;
}
_replaceRoutineStarted = true;
<initialDelay>5__1 = ((ReplaceDelaySeconds != null) ? Mathf.Max(0f, ReplaceDelaySeconds.Value) : 0f);
if (<initialDelay>5__1 > 0f)
{
LogVerbose(string.Format("[{0}] Várakozás {1:0.00} mp-ig az első logócsere előtt.", "Swap Logo", <initialDelay>5__1));
<>2__current = (object)new WaitForSeconds(<initialDelay>5__1);
<>1__state = 1;
return true;
}
goto IL_00e5;
case 1:
<>1__state = -1;
goto IL_00e5;
case 2:
<>1__state = -1;
if (<>8__7.attemptSuccess)
{
<success>5__5 = true;
LogInfo(string.Format("[{0}] A logócsere sikeres volt a(z) {1}. próbálkozásra.", "Swap Logo", <i>5__6));
break;
}
if (<i>5__6 < <attempts>5__2)
{
<>2__current = (object)new WaitForSeconds(<interval>5__3);
<>1__state = 3;
return true;
}
goto IL_0252;
case 3:
{
<>1__state = -1;
goto IL_0252;
}
IL_00e5:
<attempts>5__2 = GetRetryAttemptsByMode();
<interval>5__3 = GetRetryIntervalByMode();
<minScore>5__4 = GetMinimumScoreByMode();
LogInfo(string.Format("[{0}] Logócsere indul. Próbálkozások száma: {1}, intervallum: {2:0.00} mp, minimum pontszám: {3}", "Swap Logo", <attempts>5__2, <interval>5__3, <minScore>5__4));
<success>5__5 = false;
<i>5__6 = 1;
goto IL_026c;
IL_026c:
if (<i>5__6 <= <attempts>5__2)
{
<>8__7 = new <>c__DisplayClass33_0();
LogVerbose(string.Format("[{0}] Logócsere próbálkozás: {1}/{2}", "Swap Logo", <i>5__6, <attempts>5__2));
<>8__7.attemptSuccess = false;
<>2__current = ((MonoBehaviour)Instance).StartCoroutine(TryReplaceLogoCoroutine(delegate(bool result)
{
<>8__7.attemptSuccess = result;
}, <minScore>5__4));
<>1__state = 2;
return true;
}
break;
IL_0252:
<>8__7 = null;
<i>5__6++;
goto IL_026c;
}
if (!<success>5__5)
{
LogWarning("[Swap Logo] A logócsere egyik próbálkozás során sem sikerült.");
}
_replaceRoutineStarted = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <TryReplaceLogoCoroutine>d__34 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Action<bool> onFinished;
public int minimumScore;
private <>c__DisplayClass34_0 <>8__1;
private string <logoPath>5__2;
private Image[] <images>5__3;
private Image <bestMatch>5__4;
private int <bestScore>5__5;
private bool <shouldAnimate>5__6;
private Image[] <>s__7;
private int <>s__8;
private Image <img>5__9;
private int <score>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TryReplaceLogoCoroutine>d__34(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<logoPath>5__2 = null;
<images>5__3 = null;
<bestMatch>5__4 = null;
<>s__7 = null;
<img>5__9 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass34_0();
if ((Object)(object)Instance == (Object)null)
{
LogWarning("[Swap Logo] A plugin példány nem elérhető.");
onFinished?.Invoke(obj: false);
return false;
}
<logoPath>5__2 = GetLogoPath();
<>8__1.customSprite = null;
<>2__current = ((MonoBehaviour)Instance).StartCoroutine(LoadSpriteFromFileCoroutine(<logoPath>5__2, delegate(Sprite sprite)
{
<>8__1.customSprite = sprite;
}));
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)<>8__1.customSprite == (Object)null)
{
LogWarning("[Swap Logo] A saját logó betöltése sikertelen.");
onFinished?.Invoke(obj: false);
return false;
}
<images>5__3 = Resources.FindObjectsOfTypeAll<Image>();
if (<images>5__3 == null || <images>5__3.Length == 0)
{
LogWarning("[Swap Logo] Nem találtam UI Image objektumokat.");
onFinished?.Invoke(obj: false);
return false;
}
LogVerbose(string.Format("[{0}] Talált Image objektumok száma: {1}", "Swap Logo", <images>5__3.Length));
if (DumpAllImages != null && DumpAllImages.Value)
{
DumpImageCandidates(<images>5__3);
}
<bestMatch>5__4 = null;
<bestScore>5__5 = int.MinValue;
<>s__7 = <images>5__3;
for (<>s__8 = 0; <>s__8 < <>s__7.Length; <>s__8++)
{
<img>5__9 = <>s__7[<>s__8];
if (!((Object)(object)<img>5__9 == (Object)null) && !((Object)(object)((Component)<img>5__9).gameObject == (Object)null))
{
<score>5__10 = CalculateImageScore(<img>5__9);
if (<score>5__10 > <bestScore>5__5)
{
<bestScore>5__5 = <score>5__10;
<bestMatch>5__4 = <img>5__9;
}
<img>5__9 = null;
}
}
<>s__7 = null;
if ((Object)(object)<bestMatch>5__4 == (Object)null)
{
LogWarning("[Swap Logo] Nem találtam megfelelő logó objektumot a cseréhez.");
onFinished?.Invoke(obj: false);
return false;
}
if (<bestScore>5__5 < minimumScore)
{
LogWarning(string.Format("[{0}] A legjobb találat pontszáma túl alacsony: {1}. Minimum szükséges: {2}. Objektum: {3}", "Swap Logo", <bestScore>5__5, minimumScore, ((Object)((Component)<bestMatch>5__4).gameObject).name));
onFinished?.Invoke(obj: false);
return false;
}
ApplyLogo(<bestMatch>5__4, <>8__1.customSprite);
<shouldAnimate>5__6 = EnableFade != null && EnableFade.Value && !_fadeAlreadyPlayed;
if (<shouldAnimate>5__6)
{
_fadeAlreadyPlayed = true;
<>2__current = ((MonoBehaviour)Instance).StartCoroutine(FadeInLogoCoroutine(<bestMatch>5__4));
<>1__state = 2;
return true;
}
break;
case 2:
<>1__state = -1;
break;
}
_lastAppliedObjectName = ((Object)((Component)<bestMatch>5__4).gameObject).name;
LogInfo(string.Format("[{0}] A logó sikeresen lecserélve erre az objektumra: {1} | Pontszám: {2}", "Swap Logo", ((Object)((Component)<bestMatch>5__4).gameObject).name, <bestScore>5__5));
onFinished?.Invoke(obj: true);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public const string ModGuid = "h4nz0.valheim.swaplogo";
public const string ModName = "Swap Logo";
public const string ModVersion = "1.1.0";
internal static SwapLogoPlugin Instance;
internal static ManualLogSource Log;
private Harmony _harmony;
internal static ConfigEntry<bool> ModEnabled;
internal static ConfigEntry<bool> VerboseLogging;
internal static ConfigEntry<string> LogoFileName;
internal static ConfigEntry<float> ReplaceDelaySeconds;
internal static ConfigEntry<bool> UseFixedSize;
internal static ConfigEntry<float> FixedWidth;
internal static ConfigEntry<float> FixedHeight;
internal static ConfigEntry<float> LogoScale;
internal static ConfigEntry<bool> EnableFade;
internal static ConfigEntry<float> FadeDuration;
internal static ConfigEntry<string> CompatibilityMode;
internal static ConfigEntry<int> RetryCount;
internal static ConfigEntry<float> RetryIntervalSeconds;
internal static ConfigEntry<int> MinimumScoreThreshold;
internal static ConfigEntry<bool> DumpAllImages;
private static bool _replaceRoutineStarted;
private static bool _fadeAlreadyPlayed;
private static string _lastAppliedObjectName = string.Empty;
private void Awake()
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
InitConfig();
if (!ModEnabled.Value)
{
Log.LogInfo((object)"[Swap Logo] A mod ki van kapcsolva a configban.");
return;
}
_harmony = new Harmony("h4nz0.valheim.swaplogo");
_harmony.PatchAll();
Log.LogInfo((object)"[Swap Logo] Betöltve.");
Log.LogInfo((object)("[Swap Logo] Logó elérési út: " + GetLogoPath()));
Log.LogInfo((object)("[Swap Logo] Kompatibilitási mód: " + CompatibilityMode.Value));
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void InitConfig()
{
ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "A mod be- vagy kikapcsolása.");
VerboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "VerboseLogging", true, "Részletes naplózás be- vagy kikapcsolása.");
LogoFileName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "LogoFileName", "logo.png", "A betöltendő logófájl neve a plugin saját mappájából.");
ReplaceDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ReplaceDelaySeconds", 0.75f, "Ennyi másodpercet vár a főmenü indulása után, mielőtt megpróbálja lecserélni a logót.");
UseFixedSize = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "UseFixedSize", true, "Fix UI méretet használjon a logóhoz.");
FixedWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "FixedWidth", 900f, "A logó fix szélessége UI egységben.");
FixedHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "FixedHeight", 260f, "A logó fix magassága UI egységben.");
LogoScale = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "LogoScale", 1f, "A logó méretezése a fix méret után. 1.0 = alap, 0.8 = kisebb, 1.2 = nagyobb.");
EnableFade = ((BaseUnityPlugin)this).Config.Bind<bool>("Animation", "EnableFade", true, "Áttűnéses animáció használata a logócsere után.");
FadeDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Animation", "FadeDuration", 0.8f, "Az áttűnés animáció hossza másodpercben.");
CompatibilityMode = ((BaseUnityPlugin)this).Config.Bind<string>("Compatibility", "CompatibilityMode", "Auto", "Kompatibilitási mód. Lehetséges értékek: Strict, Auto, Aggressive");
RetryCount = ((BaseUnityPlugin)this).Config.Bind<int>("Compatibility", "RetryCount", 4, "Hányszor próbálja meg újra a logócserét, ha elsőre nem sikerül.");
RetryIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Compatibility", "RetryIntervalSeconds", 0.75f, "Ennyi időt vár két újrapróbálkozás között.");
MinimumScoreThreshold = ((BaseUnityPlugin)this).Config.Bind<int>("Compatibility", "MinimumScoreThreshold", 50, "A minimális pontszám, ami felett egy UI elem megfelelő jelöltnek számít.");
DumpAllImages = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DumpAllImages", false, "Ha engedélyezve van, kilogolja az összes talált UI Image objektumot és pontszámukat.");
((BaseUnityPlugin)this).Config.Save();
}
internal static string GetLogoPath()
{
try
{
if ((Object)(object)Instance == (Object)null || ((BaseUnityPlugin)Instance).Info == null)
{
return Path.Combine(Paths.PluginPath, "SwapLogo", LogoFileName.Value);
}
string location = ((BaseUnityPlugin)Instance).Info.Location;
if (string.IsNullOrWhiteSpace(location))
{
return Path.Combine(Paths.PluginPath, "SwapLogo", LogoFileName.Value);
}
string directoryName = Path.GetDirectoryName(location);
if (string.IsNullOrWhiteSpace(directoryName))
{
return Path.Combine(Paths.PluginPath, "SwapLogo", LogoFileName.Value);
}
string text = Path.Combine(directoryName, "SwapLogo");
if (!Directory.Exists(text))
{
Directory.CreateDirectory(text);
LogInfo("[Swap Logo] SwapLogo mappa létrehozva: " + text);
}
string text2 = Path.Combine(text, LogoFileName.Value);
LogVerbose("[Swap Logo] Keresett logó útvonal: " + text2);
return text2;
}
catch (Exception arg)
{
LogError(string.Format("[{0}] Hiba a logó elérési út meghatározásakor: {1}", "Swap Logo", arg));
return Path.Combine(Paths.PluginPath, "SwapLogo", LogoFileName.Value);
}
}
internal static void LogInfo(string message)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)message);
}
}
internal static void LogWarning(string message)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)message);
}
}
internal static void LogError(string message)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)message);
}
}
internal static void LogVerbose(string message)
{
if (VerboseLogging != null && VerboseLogging.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)message);
}
}
}
[IteratorStateMachine(typeof(<LoadSpriteFromFileCoroutine>d__32))]
internal static IEnumerator LoadSpriteFromFileCoroutine(string filePath, Action<Sprite> onLoaded)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadSpriteFromFileCoroutine>d__32(0)
{
filePath = filePath,
onLoaded = onLoaded
};
}
[IteratorStateMachine(typeof(<ReplaceLogoDelayed>d__33))]
internal static IEnumerator ReplaceLogoDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReplaceLogoDelayed>d__33(0);
}
[IteratorStateMachine(typeof(<TryReplaceLogoCoroutine>d__34))]
internal static IEnumerator TryReplaceLogoCoroutine(Action<bool> onFinished, int minimumScore)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TryReplaceLogoCoroutine>d__34(0)
{
onFinished = onFinished,
minimumScore = minimumScore
};
}
internal static int CalculateImageScore(Image img)
{
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Unknown result type (might be due to invalid IL or missing references)
//IL_020e: Unknown result type (might be due to invalid IL or missing references)
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)img == (Object)null || (Object)(object)((Component)img).gameObject == (Object)null)
{
return int.MinValue;
}
GameObject gameObject = ((Component)img).gameObject;
RectTransform rectTransform = ((Graphic)img).rectTransform;
string text = ((Object)gameObject).name ?? string.Empty;
string text2 = text.ToLowerInvariant();
string text3 = (((Object)(object)img.sprite != (Object)null && !string.IsNullOrWhiteSpace(((Object)img.sprite).name)) ? ((Object)img.sprite).name.ToLowerInvariant() : string.Empty);
int num = 0;
if (text2.Contains("logo"))
{
num += 100;
}
if (text2.Contains("valheim"))
{
num += 80;
}
if (text2.Contains("title"))
{
num += 40;
}
if (text2.Contains("menu"))
{
num += 10;
}
if (text3.Contains("logo"))
{
num += 50;
}
if (text3.Contains("valheim"))
{
num += 40;
}
if (gameObject.activeInHierarchy)
{
num += 15;
}
if (((Behaviour)img).enabled)
{
num += 10;
}
if ((Object)(object)((Graphic)img).canvasRenderer != (Object)null && ((Graphic)img).canvasRenderer.GetAlpha() > 0.01f)
{
num += 10;
}
Rect rect;
if ((Object)(object)rectTransform != (Object)null)
{
rect = rectTransform.rect;
float width = ((Rect)(ref rect)).width;
rect = rectTransform.rect;
float num2 = Mathf.Abs(width * ((Rect)(ref rect)).height);
if (num2 > 10000f)
{
num += 10;
}
if (num2 > 50000f)
{
num += 10;
}
if (num2 > 150000f)
{
num += 10;
}
Vector3 position = ((Transform)rectTransform).position;
if (position.y > (float)Screen.height * 0.45f)
{
num += 10;
}
}
string text4 = NormalizeMode((CompatibilityMode != null) ? CompatibilityMode.Value : "Auto");
string text5 = text4;
string text6 = text5;
if (!(text6 == "STRICT"))
{
if (text6 == "AGGRESSIVE")
{
if ((Object)(object)rectTransform != (Object)null)
{
rect = rectTransform.rect;
float width2 = ((Rect)(ref rect)).width;
rect = rectTransform.rect;
float num3 = Mathf.Abs(width2 * ((Rect)(ref rect)).height);
if (num3 > 30000f)
{
num += 15;
}
}
if (gameObject.activeInHierarchy)
{
num += 10;
}
}
}
else
{
if (!text2.Contains("logo") && !text3.Contains("logo"))
{
num -= 40;
}
if (!text2.Contains("valheim") && !text3.Contains("valheim"))
{
num -= 20;
}
}
LogVerbose(string.Format("[{0}] Vizsgált objektum: {1} | Sprite: {2} | Pontszám: {3}", "Swap Logo", text, text3, num));
return num;
}
internal static void DumpImageCandidates(Image[] images)
{
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
if (images == null || images.Length == 0)
{
return;
}
LogInfo("[Swap Logo] --- UI Image dump indul ---");
foreach (Image val in images)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
{
string text = ((Object)((Component)val).gameObject).name ?? "<névtelen>";
string text2 = (((Object)(object)val.sprite != (Object)null) ? ((Object)val.sprite).name : "<nincs sprite>");
string hierarchyPath = GetHierarchyPath(((Component)val).transform);
RectTransform rectTransform = ((Graphic)val).rectTransform;
object obj;
if (!((Object)(object)rectTransform != (Object)null))
{
obj = "nincs RectTransform";
}
else
{
Rect rect = rectTransform.rect;
object arg = ((Rect)(ref rect)).width;
rect = rectTransform.rect;
obj = $"size=({arg:0.##}x{((Rect)(ref rect)).height:0.##}), pos={rectTransform.anchoredPosition}";
}
string text3 = (string)obj;
int num = CalculateImageScore(val);
LogInfo(string.Format("[{0}] Image: {1} | Sprite: {2} | Active: {3} | {4} | Score: {5} | Path: {6}", "Swap Logo", text, text2, ((Component)val).gameObject.activeInHierarchy, text3, num, hierarchyPath));
}
}
LogInfo("[Swap Logo] --- UI Image dump vége ---");
}
internal static string GetHierarchyPath(Transform transform)
{
if ((Object)(object)transform == (Object)null)
{
return "<null>";
}
List<string> list = new List<string>();
Transform val = transform;
while ((Object)(object)val != (Object)null)
{
list.Insert(0, ((Object)val).name);
val = val.parent;
}
return string.Join("/", list);
}
internal static void ApplyLogo(Image targetImage, Sprite newSprite)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)targetImage == (Object)null || (Object)(object)newSprite == (Object)null)
{
return;
}
targetImage.sprite = newSprite;
targetImage.overrideSprite = newSprite;
((Behaviour)targetImage).enabled = true;
targetImage.preserveAspect = true;
targetImage.type = (Type)0;
((Graphic)targetImage).material = null;
Color white = Color.white;
white.a = 1f;
((Graphic)targetImage).color = white;
RectTransform rectTransform = ((Graphic)targetImage).rectTransform;
if ((Object)(object)rectTransform != (Object)null)
{
if (UseFixedSize != null && UseFixedSize.Value)
{
rectTransform.sizeDelta = new Vector2(Mathf.Max(1f, FixedWidth.Value), Mathf.Max(1f, FixedHeight.Value));
}
else
{
Rect rect = newSprite.rect;
float num = Mathf.Max(1f, ((Rect)(ref rect)).width);
rect = newSprite.rect;
rectTransform.sizeDelta = new Vector2(num, Mathf.Max(1f, ((Rect)(ref rect)).height));
}
((Transform)rectTransform).localScale = Vector3.one * Mathf.Max(0.01f, LogoScale.Value);
}
DebugLogoState(targetImage, newSprite);
}
internal static void DebugLogoState(Image targetImage, Sprite sprite)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)targetImage == (Object)null) && !((Object)(object)sprite == (Object)null))
{
RectTransform rectTransform = ((Graphic)targetImage).rectTransform;
Rect rect = sprite.rect;
object arg = ((Rect)(ref rect)).width;
rect = sprite.rect;
LogInfo(string.Format("[{0}] Sprite méret: {1} x {2}", "Swap Logo", arg, ((Rect)(ref rect)).height));
LogInfo(string.Format("[{0}] Image color: {1}", "Swap Logo", ((Graphic)targetImage).color));
LogInfo("[Swap Logo] Utoljára alkalmazott objektum: " + _lastAppliedObjectName);
if ((Object)(object)rectTransform != (Object)null)
{
LogInfo(string.Format("[{0}] Rect sizeDelta: {1}", "Swap Logo", rectTransform.sizeDelta));
LogInfo(string.Format("[{0}] Rect localScale: {1}", "Swap Logo", ((Transform)rectTransform).localScale));
LogInfo(string.Format("[{0}] Rect anchoredPosition: {1}", "Swap Logo", rectTransform.anchoredPosition));
}
}
}
[IteratorStateMachine(typeof(<FadeInLogoCoroutine>d__40))]
internal static IEnumerator FadeInLogoCoroutine(Image targetImage)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <FadeInLogoCoroutine>d__40(0)
{
targetImage = targetImage
};
}
internal static string NormalizeMode(string mode)
{
if (string.IsNullOrWhiteSpace(mode))
{
return "AUTO";
}
return mode.Trim().ToUpperInvariant();
}
internal static int GetRetryAttemptsByMode()
{
string text = NormalizeMode((CompatibilityMode != null) ? CompatibilityMode.Value : "Auto");
int num = ((RetryCount != null) ? Mathf.Max(1, RetryCount.Value) : 4);
string text2 = text;
string text3 = text2;
if (!(text3 == "STRICT"))
{
if (text3 == "AGGRESSIVE")
{
return Mathf.Max(num, 6);
}
return Mathf.Max(num, 4);
}
return Mathf.Max(1, num);
}
internal static float GetRetryIntervalByMode()
{
string text = NormalizeMode((CompatibilityMode != null) ? CompatibilityMode.Value : "Auto");
float num = ((RetryIntervalSeconds != null) ? Mathf.Max(0.1f, RetryIntervalSeconds.Value) : 0.75f);
string text2 = text;
string text3 = text2;
if (!(text3 == "STRICT"))
{
if (text3 == "AGGRESSIVE")
{
return Mathf.Max(0.25f, num);
}
return num;
}
return num;
}
internal static int GetMinimumScoreByMode()
{
string text = NormalizeMode((CompatibilityMode != null) ? CompatibilityMode.Value : "Auto");
int num = ((MinimumScoreThreshold != null) ? Mathf.Max(0, MinimumScoreThreshold.Value) : 50);
string text2 = text;
string text3 = text2;
if (!(text3 == "STRICT"))
{
if (text3 == "AGGRESSIVE")
{
return Mathf.Min(num, 35);
}
return num;
}
return Mathf.Max(num, 80);
}
}
[HarmonyPatch(typeof(FejdStartup), "Start")]
public static class FejdStartup_Start_Patch
{
private static void Postfix(FejdStartup __instance)
{
if (SwapLogoPlugin.ModEnabled != null && SwapLogoPlugin.ModEnabled.Value)
{
if ((Object)(object)__instance == (Object)null)
{
SwapLogoPlugin.LogWarning("[Swap Logo] A FejdStartup példány null.");
return;
}
SwapLogoPlugin.LogVerbose("[Swap Logo] FejdStartup.Start postfix lefutott.");
((MonoBehaviour)__instance).StartCoroutine(SwapLogoPlugin.ReplaceLogoDelayed());
}
}
}
