using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;
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("SkillBarVisibility")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SkillBarVisibility")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.0.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
namespace SkillBarVisibility;
[BepInPlugin("Lisonna.SkillBarVisibility", "SkillBarVisibility", "0.0.1")]
[BepInProcess("valheim.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class SkillBarVisibility : BaseUnityPlugin
{
public class SkillBarContainer : MonoBehaviour
{
private GameObject m_container = new GameObject("SkillBarContainer", new Type[1] { typeof(RectTransform) });
private Dictionary<SkillType, GameObject> m_skillBars = new Dictionary<SkillType, GameObject>();
private GameObject[] m_activeBars = (GameObject[])(object)new GameObject[30];
public SkillBarContainer()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: 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_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Expected O, but got Unknown
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
m_container.transform.SetParent(GUIManager.CustomGUIBack.transform, false);
m_container.GetComponent<RectTransform>().anchoredPosition = new Vector2(s_containerXOffset, s_containerYOffset);
foreach (SkillType value2 in Enum.GetValues(typeof(SkillType)))
{
SkillType val = value2;
if (s_iconSpriteNames.TryGetValue(val, out var value))
{
Sprite prefab = Cache.GetPrefab<Sprite>(value);
UIExtensions.ProgressBarConfig config = new UIExtensions.ProgressBarConfig
{
icon = prefab,
name = ((object)(SkillType)(ref val)).ToString(),
height = s_barHeight,
width = s_barWidth,
enableIcon = true,
valueScale = 10f,
bgColor = new Color(0f, 0f, 0f, 0.7f),
bgSprite = s_skillBarBkg,
fgColor = GUIManager.Instance.ValheimBeige,
fgSprite = s_skillBarFrg
};
GameObject val2 = new GameObject("SkillBar " + value);
SkillBar skillBar = val2.AddComponent<SkillBar>();
skillBar.Init(m_container.transform, config, val, this);
val2.SetActive(false);
m_skillBars.Add(val, val2);
}
}
m_container.SetActive(true);
}
public void InitializeSkillBars(Player player)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
Skills skills = ((Character)player).GetSkills();
foreach (GameObject value in m_skillBars.Values)
{
Logger.LogInfo((object)"test1");
SkillBar component = value.GetComponent<SkillBar>();
Logger.LogInfo((object)"test2");
Skill skill = skills.GetSkill(component.m_skillType);
Logger.LogInfo((object)"test3");
if (skill != null)
{
component.UpdateSkill(skill, suppressShow: true);
}
else
{
component.ResetBar();
}
}
}
public void UpdateSkill(SkillType skillType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
if (m_skillBars.TryGetValue(skillType, out var value))
{
value.GetComponent<SkillBar>().UpdateSkill();
}
}
public GameObject GetSkillBar(SkillType skillType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
m_skillBars.TryGetValue(skillType, out var value);
return value;
}
public void BarEnabled(GameObject bar)
{
if (m_activeBars.Contains(bar))
{
return;
}
for (int i = 0; i < m_activeBars.Count(); i++)
{
if ((Object)(object)m_activeBars[i] == (Object)null)
{
m_activeBars[i] = bar;
bar.GetComponent<SkillBar>().SetYOffset((s_barHeight + s_barPadding) * (float)i * -1f);
break;
}
}
}
public void BarDisabled(GameObject bar)
{
for (int i = 0; i < m_activeBars.Count(); i++)
{
if ((Object)(object)m_activeBars[i] == (Object)(object)bar)
{
m_activeBars[i] = null;
break;
}
}
}
public void OnDestroy()
{
Logger.LogInfo((object)"skillbarcontainer destroyed?");
s_skillBarContainer = null;
}
}
public class SkillBar : UIExtensions.ProgressBar
{
public SkillType m_skillType;
public Skill m_skill;
private SkillBarContainer m_container;
private float m_level;
private bool m_suppressDisable;
public void Init(Transform parent, UIExtensions.ProgressBarConfig config, SkillType skillType, SkillBarContainer sbc, float startingValue = 0f)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
base.Init(parent, config, startingValue);
m_skillType = skillType;
m_container = sbc;
m_suppressDisable = true;
}
public void Init(Transform parent, UIExtensions.ProgressBarConfig config, SkillType skillType, float startingValue = 0f)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
base.Init(parent, config, startingValue);
m_skillType = skillType;
m_suppressDisable = true;
}
public void UpdateSkill(Skill skill, bool suppressShow = false)
{
m_skill = skill;
UpdateValues(suppressShow);
}
public void UpdateSkill(bool suppressShow = false)
{
UpdateValues(suppressShow);
}
private void UpdateValues(bool suppressShow = false)
{
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
float level = m_level;
m_level = m_skill.m_level;
float currentValue = GetCurrentValue();
float num = GetTotalValue() - currentValue;
SetCenterText(((int)m_skill.m_level).ToString());
SetCurrentValue(m_skill.m_accumulator);
SetTotal(m_skill.GetNextLevelRequirement());
if (!suppressShow)
{
EnableSkillBar();
if (s_showGainText && level <= m_level)
{
((Component)this).gameObject.AddComponent<UIExtensions.MovingText>().Init(new UIExtensions.MovingTextConfig
{
duration = 3f,
relativeEndFromStart = new Vector2(125f, 0f),
disableTextOnEnd = true,
deactivateGameObjectAfter = false
}, new UIExtensions.TextObjectConfig
{
text = "+" + FormatValueText((level < m_level) ? num : (m_skill.m_accumulator - currentValue)),
fontSize = 16,
color = Color.green,
xOffset = -75f
});
}
}
}
private void EnableSkillBar()
{
((Component)this).gameObject.SetActive(true);
((Behaviour)this).enabled = true;
SetAlpha(1f);
UIExtensions.UIAnimation.StartFaderAfterTime(((Component)this).gameObject, s_barVisibilityDuration, s_fadeoutDuration);
m_container?.BarEnabled(((Component)this).gameObject);
}
public void ResetBar()
{
SetCurrentValue(0f);
SetTotal(1f);
SetCenterText("1");
}
public void OnDisable()
{
if (!m_suppressDisable)
{
m_container?.BarDisabled(((Component)this).gameObject);
}
else
{
m_suppressDisable = false;
}
}
}
[HarmonyPatch(typeof(Skill), "Raise")]
private class Skill_Patches
{
[HarmonyPostfix]
private static void Postfix(Skill __instance)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
UpdateSkillBar(__instance.m_info.m_skill);
}
}
[HarmonyPatch(typeof(Skills), "LowerAllSkills")]
private class Skills_Patches
{
[HarmonyPostfix]
private static void Postfix(Skills __instance)
{
if ((Object)(object)Player.m_localPlayer == (Object)(object)__instance.m_player)
{
s_skillBarContainer.InitializeSkillBars(__instance.m_player);
}
}
}
[HarmonyPatch(typeof(Player), "Load")]
private class PlayerLoad_Patches
{
[HarmonyPostfix]
private static void Postfix(Player __instance)
{
if ((Object)(object)Player.m_localPlayer == (Object)(object)__instance)
{
int width = Screen.width;
int height = Screen.height;
Logger.LogInfo((object)("Current resolution: " + width + "x" + height));
if ((Object)(object)s_skillBarContainer == (Object)null)
{
s_skillBarContainer = new SkillBarContainer();
s_skillBarContainer.InitializeSkillBars(__instance);
}
}
}
}
public const string PluginGUID = "Lisonna.SkillBarVisibility";
public const string PluginName = "SkillBarVisibility";
public const string PluginVersion = "0.0.1";
public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();
private readonly Harmony harmony = new Harmony("Lisonna.SkillBarVisibility");
public static SkillBarContainer s_skillBarContainer;
private static Dictionary<SkillType, string> s_iconSpriteNames = new Dictionary<SkillType, string>
{
{
(SkillType)1,
"SwordIron"
},
{
(SkillType)2,
"knife_flint"
},
{
(SkillType)3,
"club"
},
{
(SkillType)4,
"AtgeirBronze"
},
{
(SkillType)5,
"SpearFlint"
},
{
(SkillType)6,
"shield_banded1"
},
{
(SkillType)7,
"axe_iron"
},
{
(SkillType)8,
"bow"
},
{
(SkillType)9,
"elemental_magic"
},
{
(SkillType)10,
"blood_magic"
},
{
(SkillType)11,
"hands"
},
{
(SkillType)12,
"pickaxe_stone"
},
{
(SkillType)13,
"skill_woodcutting"
},
{
(SkillType)14,
"crossbow_arbalest"
},
{
(SkillType)100,
"skill_jump"
},
{
(SkillType)101,
"skill_sneak"
},
{
(SkillType)102,
"skill_run"
},
{
(SkillType)103,
"skill_swim"
},
{
(SkillType)104,
"fishingrod"
},
{
(SkillType)105,
"meat_cooked"
},
{
(SkillType)106,
"cultivator_bronze"
},
{
(SkillType)107,
"hammer"
},
{
(SkillType)108,
"skill_dodge"
},
{
(SkillType)110,
"SadleLox"
}
};
private static Dictionary<SkillType, Sprite> s_skillSprites = new Dictionary<SkillType, Sprite>();
private static Sprite s_skillBarBkg;
private static Sprite s_skillBarFrg;
public static float s_containerXOffset = -800f;
public static float s_containerYOffset = 0f;
public static float s_barWidth = 250f;
public static float s_barHeight = 20f;
public static float s_barPadding = 4f;
public static float s_barVisibilityDuration = 5f;
public static float s_fadeoutDuration = 2f;
public static bool s_showGainText = true;
private void Awake()
{
PrefabManager.OnVanillaPrefabsAvailable += OnPrefabsAvail;
harmony.PatchAll();
}
private void OnPrefabsAvail()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
foreach (KeyValuePair<SkillType, string> s_iconSpriteName in s_iconSpriteNames)
{
Sprite prefab = Cache.GetPrefab<Sprite>(s_iconSpriteName.Value);
if ((Object)(object)prefab != (Object)null)
{
s_skillSprites.Add(s_iconSpriteName.Key, prefab);
}
}
s_skillBarBkg = Cache.GetPrefab<Sprite>("skill_bkg");
s_skillBarFrg = Cache.GetPrefab<Sprite>("bar_food_8");
PrefabManager.OnVanillaPrefabsAvailable -= OnPrefabsAvail;
}
private void OnDestroy()
{
harmony.UnpatchSelf();
}
public static void UpdateSkillBar(SkillType skillType)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
s_skillBarContainer.UpdateSkill(skillType);
}
}
public static class RectTransformExtensions
{
public static void SetElementSize(this RectTransform rtf, float width, float height)
{
rtf.SetSizeWithCurrentAnchors((Axis)0, width);
rtf.SetSizeWithCurrentAnchors((Axis)1, height);
}
}
internal class UIExtensions
{
public static class AnchorPoint
{
public static readonly Vector2 TopLeft = new Vector2(0f, 1f);
public static readonly Vector2 Top = new Vector2(0.5f, 1f);
public static readonly Vector2 TopRight = new Vector2(1f, 1f);
public static readonly Vector2 Left = new Vector2(0f, 0.5f);
public static readonly Vector2 Center = new Vector2(0.5f, 0.5f);
public static readonly Vector2 Right = new Vector2(1f, 0.5f);
public static readonly Vector2 BottomLeft = new Vector2(0f, 0f);
public static readonly Vector2 Bottom = new Vector2(0.5f, 0f);
public static readonly Vector2 BottomRight = new Vector2(1f, 0f);
public static Vector2 Reverse(Vector2 vector)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
return new Vector2(1f - vector.x, 1f - vector.y);
}
public static void SetChildPointToParentPoint(RectTransform rtf, Vector2 childPoint, Vector2 parentPoint, float xOffset = 0f, float yOffset = 0f)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
rtf.anchorMin = parentPoint;
rtf.anchorMax = rtf.anchorMin;
rtf.pivot = childPoint;
rtf.anchoredPosition = new Vector2(xOffset, yOffset);
}
public static void SetChildToFillParent(RectTransform rtf)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
rtf.anchorMin = BottomLeft;
rtf.anchorMax = TopRight;
rtf.pivot = Center;
rtf.sizeDelta = Vector2.zero;
rtf.anchoredPosition = Vector2.zero;
}
public static GameObject CreateGOAndSetParentPoint(string name, Transform parent, Vector2 childPoint, Vector2 parentPoint, float xOffset = 0f, float yOffset = 0f, params Type[] components)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, components);
val.transform.SetParent(parent, false);
SetChildPointToParentPoint(ExposedGameObjectExtension.GetOrAddComponent<RectTransform>(val), childPoint, parentPoint, xOffset, yOffset);
return val;
}
public static GameObject CreateGOAndSetChildFillParent(string name, Transform parent, params Type[] components)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
GameObject val = CreateGOAndSetParentPoint(name, parent, Center, Center, 0f, 0f, components);
SetChildToFillParent(val.GetComponent<RectTransform>());
return val;
}
}
public class RectangleConfig
{
}
public class TextObjectConfig
{
public string text = "";
private int _fontSize = 16;
public bool outline = true;
public Color color;
public Font font = GUIManager.Instance.AveriaSerif;
public float xOffset = 0f;
public float yOffset = 0f;
public int fontSize
{
get
{
return _fontSize;
}
set
{
if (value > 0)
{
_fontSize = value;
return;
}
throw new ArgumentOutOfRangeException("value", "Fontsize must be a positive, non-zero value");
}
}
}
public class ProgressBarConfig
{
private float _height = 20f;
private float _width = 200f;
public float xOffset = 0f;
public float yOffset = 0f;
private float _total = 100f;
public Sprite icon;
public bool enableIcon = false;
public bool flipIconPosition = false;
public Color bgColor = Color.black;
public Color fgColor = Color.white;
public Sprite bgSprite;
public Sprite fgSprite;
public Direction direction = (Direction)0;
public bool inverse = false;
public string name = "";
public string centerText = "";
public int fontSize = 16;
public int valueTextDecimals = 0;
public float valueScale = 1f;
public float height
{
get
{
return _height;
}
set
{
if (value > 0f)
{
_height = value;
return;
}
throw new ArgumentOutOfRangeException("value", "Height must be a positive, non-zero value");
}
}
public float width
{
get
{
return _width;
}
set
{
if (value > 0f)
{
_width = value;
return;
}
throw new ArgumentOutOfRangeException("value", "Width must be a positive, non-zero value");
}
}
public float total
{
get
{
return _total;
}
set
{
if (value > 0f)
{
_total = value;
return;
}
throw new ArgumentOutOfRangeException("value", "Total must be a positive, non-zero value");
}
}
}
public class ProgressBar : MonoBehaviour
{
public ProgressBarConfig m_config;
protected GameObject m_barsContainer;
protected GameObject m_backgroundBar;
protected GameObject m_foregroundBar;
protected Slider m_sliderBar;
protected GameObject m_iconContainer;
protected GameObject m_icon;
protected GameObject m_textsContainer;
protected GameObject m_valueText;
protected GameObject m_totalText;
protected GameObject m_centerText;
public virtual void Init(Transform parent, ProgressBarConfig config, float startingValue)
{
m_config = config;
SetupContainer(parent);
SetupIcon();
SetupBars();
SetupSlider(startingValue);
SetupTexts();
((Component)this).gameObject.SetActive(true);
}
private void SetupContainer(Transform parent)
{
//IL_003e: 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)
RectTransform orAddComponent = ExposedGameObjectExtension.GetOrAddComponent<RectTransform>(((Component)this).gameObject);
((Component)this).gameObject.transform.SetParent(parent, false);
orAddComponent.SetElementSize(m_config.width, m_config.height);
AnchorPoint.SetChildPointToParentPoint(orAddComponent, AnchorPoint.Center, AnchorPoint.Center, m_config.xOffset, m_config.yOffset);
((Component)this).gameObject.AddComponent<CanvasGroup>();
}
public void SetName(string name)
{
m_config.name = name;
}
public void SetAlpha(float alpha)
{
alpha = Mathf.Clamp01(alpha);
((Component)this).gameObject.GetComponent<CanvasGroup>().alpha = alpha;
}
public void SetXOffset(float x, bool relative = false)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
RectTransform component = ((Component)this).gameObject.GetComponent<RectTransform>();
if (relative)
{
component.anchoredPosition += new Vector2(x, 0f);
}
else
{
component.anchoredPosition = new Vector2(x, component.anchoredPosition.y);
}
m_config.xOffset = component.anchoredPosition.x;
}
public void SetYOffset(float y, bool relative = false)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
RectTransform component = ((Component)this).gameObject.GetComponent<RectTransform>();
if (relative)
{
component.anchoredPosition += new Vector2(0f, y);
}
else
{
component.anchoredPosition = new Vector2(component.anchoredPosition.x, y);
}
m_config.yOffset = component.anchoredPosition.y;
}
public void SetHeight(float height)
{
m_config.height = height;
((Component)this).gameObject.GetComponent<RectTransform>().SetElementSize(m_config.width, m_config.height);
SetIconSize();
}
public void SetWidth(float width)
{
m_config.width = width;
((Component)this).gameObject.GetComponent<RectTransform>().SetElementSize(m_config.width, m_config.height);
SetIconSize();
}
private void SetupIcon()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
m_iconContainer = AnchorPoint.CreateGOAndSetParentPoint("ProgressBarIconContainer", ((Component)this).gameObject.transform, GetIconAnchor(), AnchorPoint.Reverse(GetIconAnchor()), 0f, 0f, typeof(RectTransform));
((Graphic)m_iconContainer.AddComponent<Image>()).color = Color.black;
m_icon = AnchorPoint.CreateGOAndSetChildFillParent("ProgressBarIcon", m_iconContainer.transform, typeof(RectTransform));
m_icon.AddComponent<Image>().sprite = m_config.icon;
SetIconSize();
m_iconContainer.SetActive(m_config.enableIcon);
}
private void SetIconSize()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
if (GetIconAnchor().y == 0.5f)
{
m_iconContainer.GetComponent<RectTransform>().SetElementSize(m_config.height, m_config.height);
}
else
{
m_iconContainer.GetComponent<RectTransform>().SetElementSize(m_config.width, m_config.width);
}
}
private Vector2 GetIconAnchor()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
return m_config.flipIconPosition ? AnchorPoint.Reverse(GetFilledEndPoint()) : GetFilledEndPoint();
}
public void SetIcon(Sprite icon)
{
m_config.icon = icon;
m_icon.GetComponent<Image>().sprite = icon;
}
public void EnableIcon()
{
m_config.enableIcon = true;
m_iconContainer.SetActive(true);
}
public void DisableIcon()
{
m_config.enableIcon = false;
m_iconContainer.SetActive(false);
}
public void SetFlipIconPosition(bool flip)
{
m_config.flipIconPosition = flip;
SetIconAnchors();
}
private void SetIconAnchors()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
AnchorPoint.SetChildPointToParentPoint(((Component)this).gameObject.GetComponent<RectTransform>(), GetIconAnchor(), AnchorPoint.Reverse(GetIconAnchor()));
}
private void SetupBars()
{
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
m_barsContainer = AnchorPoint.CreateGOAndSetChildFillParent("ProgressBarBars", ((Component)this).gameObject.transform, typeof(RectTransform));
m_backgroundBar = AnchorPoint.CreateGOAndSetChildFillParent("ProgressBarBgBar", m_barsContainer.transform, typeof(RectTransform));
((Graphic)m_backgroundBar.AddComponent<Image>()).color = m_config.bgColor;
m_backgroundBar.GetComponent<Image>().sprite = m_config.bgSprite;
m_foregroundBar = AnchorPoint.CreateGOAndSetChildFillParent("ProgressBarFgBar", m_barsContainer.transform, typeof(RectTransform));
((Graphic)m_foregroundBar.AddComponent<Image>()).color = m_config.fgColor;
m_foregroundBar.GetComponent<Image>().sprite = m_config.fgSprite;
}
private void SetupSlider(float startingValue)
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
m_sliderBar = m_barsContainer.AddComponent<Slider>();
m_sliderBar.fillRect = m_foregroundBar.GetComponent<RectTransform>();
((Selectable)m_sliderBar).targetGraphic = (Graphic)(object)m_foregroundBar.GetComponent<Image>();
((Selectable)m_sliderBar).transition = (Transition)0;
((Selectable)m_sliderBar).interactable = false;
m_sliderBar.minValue = 0f;
m_sliderBar.direction = m_config.direction;
m_sliderBar.maxValue = m_config.total;
m_sliderBar.SetValueWithoutNotify(startingValue);
}
public void SetBackgroundColor(Color color)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
m_config.bgColor = color;
((Graphic)m_backgroundBar.GetComponent<Image>()).color = color;
}
public void SetForegroundColor(Color color)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
m_config.fgColor = color;
((Graphic)m_foregroundBar.GetComponent<Image>()).color = color;
}
public void SetBackgroundSprite(Sprite sprite)
{
m_config.bgSprite = sprite;
m_backgroundBar.GetComponent<Image>().sprite = sprite;
}
public void SetForegroundSprite(Sprite sprite)
{
m_config.fgSprite = sprite;
m_foregroundBar.GetComponent<Image>().sprite = sprite;
}
public void SetDirection(Direction direction)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
m_config.direction = direction;
m_sliderBar.direction = direction;
SetIconAnchors();
SetIconSize();
}
private Vector2 GetFilledEndPoint()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected I4, but got Unknown
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: 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_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
Direction direction = m_config.direction;
Direction val = direction;
return (Vector2)((int)val switch
{
0 => AnchorPoint.Right,
1 => AnchorPoint.Left,
2 => AnchorPoint.Top,
3 => AnchorPoint.Bottom,
_ => AnchorPoint.Right,
});
}
public void SetInverse(bool inverse)
{
m_config.inverse = inverse;
SetCurrentValue(GetCurrentValue());
}
private void SetupTexts()
{
//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_0042: 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_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: 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)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
m_textsContainer = AnchorPoint.CreateGOAndSetChildFillParent("ProgressBarTextContainer", ((Component)this).gameObject.transform, typeof(RectTransform));
Vector2 filledEndPoint = GetFilledEndPoint();
m_totalText = CreateTextObject(m_textsContainer.transform, filledEndPoint, filledEndPoint, new TextObjectConfig
{
color = Color.white,
fontSize = 18,
text = FormatValueText(m_sliderBar.maxValue)
});
m_valueText = CreateTextObject(m_textsContainer.transform, AnchorPoint.Reverse(filledEndPoint), AnchorPoint.Reverse(filledEndPoint), new TextObjectConfig
{
color = Color.white,
fontSize = 18,
text = FormatValueText(m_sliderBar.value)
});
m_centerText = CreateTextObject(m_textsContainer.transform, AnchorPoint.Center, AnchorPoint.Center, new TextObjectConfig
{
color = Color.white,
fontSize = 18,
text = m_config.centerText
});
}
private void UpdateValueText()
{
m_valueText.GetComponent<Text>().text = FormatValueText(m_sliderBar.value);
}
private void UpdateTotalText()
{
m_totalText.GetComponent<Text>().text = FormatValueText(m_sliderBar.maxValue);
}
private void UpdateCenterText()
{
m_centerText.GetComponent<Text>().text = m_config.centerText;
}
protected string FormatValueText(float value)
{
return Math.Round(value * m_config.valueScale, m_config.valueTextDecimals, MidpointRounding.AwayFromZero).ToString();
}
public void SetCenterText(string text)
{
m_config.centerText = text;
UpdateCenterText();
}
public float GetCurrentValue()
{
return m_sliderBar.value;
}
public float GetTotalValue()
{
return m_sliderBar.maxValue;
}
public ProgressBarConfig GetConfig()
{
return m_config;
}
public void SetTotal(float total)
{
m_config.total = total;
m_sliderBar.maxValue = total;
UpdateTotalText();
}
public float SetCurrentValue(float value)
{
float value2 = m_sliderBar.value;
m_sliderBar.SetValueWithoutNotify(m_config.inverse ? (m_config.total - value) : value);
UpdateValueText();
return value2;
}
public void SetValueTextDecimalPlaces(int decimalPlaces)
{
m_config.valueTextDecimals = decimalPlaces;
UpdateValueText();
}
public void SetValueScale(float scale)
{
m_config.valueScale = scale;
UpdateValueText();
UpdateTotalText();
}
}
public class UIAnimationConfig
{
public bool deactivateGameObjectAfter = false;
private float _duration = 1f;
public float duration
{
get
{
return _duration;
}
set
{
if (value >= 0f)
{
_duration = value;
return;
}
throw new ArgumentOutOfRangeException("value", "Duration must not be negative.");
}
}
}
public abstract class UIAnimation : MonoBehaviour
{
public float m_duration;
public float m_startTime;
public bool m_disableGameObjOnEnd = true;
public bool m_isCanceled = false;
public bool m_isPaused = false;
public static void StartFaderAfterTime(GameObject obj, float faderStart, float faderDuration, bool disableGameObjAfterFade = true)
{
obj.GetComponent<UITimedFunctionRun>()?.Cancel();
obj.GetComponent<UIFader>()?.Cancel();
obj.AddComponent<UITimedFunctionRun>().Init(new UITimedFunctionConfig
{
duration = faderStart,
action = startFader
});
void startFader()
{
obj.AddComponent<UIFader>().Init(new UIFaderConfig
{
duration = faderDuration,
deactivateGameObjectAfter = disableGameObjAfterFade
});
}
}
public virtual void Awake()
{
m_startTime = Time.time;
}
protected void Init(UIAnimationConfig config)
{
m_duration = config.duration;
m_disableGameObjOnEnd = config.deactivateGameObjectAfter;
}
public virtual void Pause()
{
m_isPaused = true;
}
public virtual void Resume()
{
m_isPaused = false;
}
public virtual void Cancel()
{
m_isCanceled = true;
((Behaviour)this).enabled = false;
}
public virtual void Update()
{
if (!m_isPaused)
{
UpdateFunction(Time.time - m_startTime);
if (m_duration > 0f && Time.time > m_startTime + m_duration)
{
((Behaviour)this).enabled = false;
}
}
else
{
m_startTime += Time.deltaTime;
}
}
public virtual void UpdateFunction(float t)
{
}
public virtual void OnDisable()
{
if (m_disableGameObjOnEnd && !m_isCanceled)
{
((Component)this).gameObject.SetActive(false);
}
Object.Destroy((Object)(object)this);
}
}
public class UITimedFunctionConfig : UIAnimationConfig
{
public Action action;
}
public class UITimedFunctionRun : UIAnimation
{
public UITimedFunctionConfig m_config;
public void Init(UITimedFunctionConfig config)
{
Init((UIAnimationConfig)config);
if (config.action == null)
{
((Behaviour)this).enabled = false;
Logger.LogWarning((object)"TimedFunction called without a function. Nothing will happen.");
}
m_config = config;
}
public override void OnDisable()
{
m_config.action?.Invoke();
base.OnDisable();
}
}
public class UIFaderConfig : UIAnimationConfig
{
}
public class UIFader : UIAnimation
{
private CanvasGroup m_canvasGroup;
public UIFaderConfig m_config;
public override void Awake()
{
base.Awake();
m_canvasGroup = ExposedGameObjectExtension.GetOrAddComponent<CanvasGroup>(((Component)this).gameObject);
}
public void Init(UIFaderConfig config)
{
Init((UIAnimationConfig)config);
m_config = config;
}
public override void Cancel()
{
m_canvasGroup.alpha = 1f;
base.Cancel();
}
public override void UpdateFunction(float t)
{
m_canvasGroup.alpha = GetAlpha(t);
}
public override void OnDisable()
{
m_canvasGroup.alpha = 1f;
base.OnDisable();
}
private float GetAlpha(float t)
{
return 1f - t / m_duration;
}
}
public class MovingTextConfig : UIAnimationConfig
{
public Vector2 relativeEndFromStart = Vector2.zero;
public bool disableTextOnEnd = true;
}
public class MovingText : UIAnimation
{
public GameObject m_textObject;
private Vector2 m_endPosition;
public MovingTextConfig m_config;
public override void Awake()
{
base.Awake();
}
public GameObject Init(MovingTextConfig config, TextObjectConfig textConfig)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
Init(config);
m_textObject = CreateTextObject(((Component)this).gameObject.transform, AnchorPoint.Center, AnchorPoint.Center, textConfig);
m_config = config;
m_endPosition = new Vector2(textConfig.xOffset + config.relativeEndFromStart.x, textConfig.yOffset + config.relativeEndFromStart.y);
return m_textObject;
}
public override void UpdateFunction(float t)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)m_textObject != (Object)null && (Object)(object)m_textObject.GetComponent<RectTransform>() != (Object)null)
{
m_textObject.GetComponent<RectTransform>().anchoredPosition = Vector2.Lerp(m_textObject.GetComponent<RectTransform>().anchoredPosition, m_endPosition, Time.deltaTime);
}
}
public override void OnDisable()
{
base.OnDisable();
if (m_config.disableTextOnEnd)
{
m_textObject.SetActive(false);
}
}
}
public static GameObject CreateTextObject(Transform parent, Vector2 childPoint, Vector2 parentPoint, TextObjectConfig config)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
GameObject val = AnchorPoint.CreateGOAndSetParentPoint("ProgressBarText", parent, childPoint, parentPoint, config.xOffset, config.yOffset, typeof(RectTransform), typeof(Text));
val.AddComponent<ContentSizeFitter>().horizontalFit = (FitMode)2;
val.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
Text component = val.GetComponent<Text>();
component.text = config.text;
((Graphic)component).color = config.color;
component.font = config.font;
component.fontSize = config.fontSize;
if (config.outline)
{
Outline val2 = val.AddComponent<Outline>();
((Shadow)val2).effectColor = Color.black;
}
return val;
}
}
