using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dolso;
using Dolso.RoO;
using ESF.Components;
using ESF.EntityStates;
using EntityStates;
using HG.BlendableTypes;
using HG.GeneralSerializer;
using HG.Reflection;
using JetBrains.Annotations;
using KinematicCharacterController;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MotorAPI;
using RiskOfOptions;
using RiskOfOptions.Components.Options;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.CameraModes;
using RoR2.ConVar;
using RoR2.ContentManagement;
using RoR2.HudOverlay;
using RoR2.Networking;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using TMPro;
using Unity;
using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace Dolso
{
internal static class Utilities
{
internal static ConfigFile configFile;
private static GameObject _prefabParent;
internal static void Awake(BaseUnityPlugin plugin)
{
configFile = plugin.Config;
}
internal static GameObject CreatePrefab(GameObject gameObject, string name = null)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
if (!Object.op_Implicit((Object)(object)_prefabParent))
{
_prefabParent = new GameObject("DolsoPrefabs");
Object.DontDestroyOnLoad((Object)(object)_prefabParent);
((Object)_prefabParent).hideFlags = (HideFlags)61;
_prefabParent.SetActive(false);
}
GameObject val = Object.Instantiate<GameObject>(gameObject, _prefabParent.transform);
if (name != null)
{
((Object)val).name = name;
}
return val;
}
internal static void ModifyStateConfig(this EntityStateConfiguration stateConfig, string fieldName, object newValue)
{
SerializedField[] serializedFields = stateConfig.serializedFieldsCollection.serializedFields;
for (int i = 0; i < serializedFields.Length; i++)
{
if (serializedFields[i].fieldName == fieldName)
{
Object val = (Object)((newValue is Object) ? newValue : null);
if (val != null)
{
serializedFields[i].fieldValue.objectValue = val;
}
else if (newValue != null && StringSerializer.CanSerializeType(newValue.GetType()))
{
serializedFields[i].fieldValue.stringValue = StringSerializer.Serialize(newValue.GetType(), newValue);
}
else
{
log.error("Invalid value for SerializedField: " + newValue);
}
return;
}
}
log.error("Failed to find " + fieldName + " for " + ((Object)stateConfig).name);
}
internal static bool IsKeyDown(this KeyboardShortcut key, bool onlyJustPressed)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if (onlyJustPressed)
{
if (!Input.GetKeyDown(((KeyboardShortcut)(ref key)).MainKey))
{
return false;
}
}
else if (!Input.GetKey(((KeyboardShortcut)(ref key)).MainKey))
{
return false;
}
foreach (KeyCode modifier in ((KeyboardShortcut)(ref key)).Modifiers)
{
if (!Input.GetKey(modifier))
{
return false;
}
}
return true;
}
}
internal class ConfigVar<T> : BaseConVar
{
internal readonly ConfigEntry<T> configEntry;
private T _value;
internal T value
{
get
{
return _value;
}
set
{
if (configEntry != null)
{
configEntry.Value = value;
}
else
{
_value = value;
}
}
}
internal ConfigVar(string section, string name, T defaultValue)
: this(section, name, defaultValue, string.Empty)
{
}
internal ConfigVar(string section, string name, T defaultValue, string description)
: base(GenerateName(section, name), (ConVarFlags)0, (string)null, $"{description} [Default: {defaultValue}]")
{
if (description.Length > 0 && Utilities.configFile != null)
{
configEntry = Utilities.configFile.Bind<T>(section, name, defaultValue, description);
SetupConfig(autoroo: true);
}
else
{
_value = defaultValue;
}
}
internal ConfigVar(string section, string name, T defaultValue, string description, float min, float max)
: this(section, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()))
{
}//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
internal ConfigVar(string section, string name, T defaultValue, ConfigDescription description)
: base(GenerateName(section, name), (ConVarFlags)0, (string)null, $"{description.Description} [Default: {defaultValue}]")
{
if (Utilities.configFile != null)
{
configEntry = Utilities.configFile.Bind<T>(section, name, defaultValue, description);
SetupConfig(autoroo: true);
}
else
{
_value = defaultValue;
}
}
internal ConfigVar(ConfigEntry<T> entry, bool autoroo = true)
: base(GenerateName(((ConfigEntryBase)entry).Definition.Section, ((ConfigEntryBase)entry).Definition.Key), (ConVarFlags)0, (string)null, $"{((ConfigEntryBase)entry).Description.Description} [Default: {((ConfigEntryBase)entry).DefaultValue}]")
{
configEntry = entry;
SetupConfig(autoroo);
}
public override void SetString(string newValue)
{
string text = ((object)this).ToString();
if (configEntry != null)
{
((ConfigEntryBase)configEntry).SetSerializedValue(newValue);
}
else
{
_value = TomlTypeConverter.ConvertToValue<T>(newValue);
}
Debug.LogFormat("\"{0}\" set from \"{1}\" to \"{2}\"", new object[3]
{
base.name,
text,
((object)this).ToString()
});
}
public override string GetString()
{
return TomlTypeConverter.ConvertToString((object)_value, typeof(T));
}
public override string ToString()
{
return TomlTypeConverter.ConvertToString((object)_value, typeof(T));
}
protected virtual void SetupConfig(bool autoroo)
{
configEntry.SettingChanged += ConfigValueChanged;
_value = configEntry.Value;
if (autoroo && RiskofOptions.enabled)
{
AddToRoO();
}
}
private void AddToRoO()
{
RiskofOptions.AddOption((ConfigEntryBase)(object)configEntry);
}
private void ConfigValueChanged(object sender, EventArgs args)
{
_value = configEntry.Value;
}
private static string GenerateName(string section, string name)
{
return (Assembly.GetExecutingAssembly().GetName().Name + "_" + section + "_" + name).ToLower().Replace(' ', '_');
}
public static implicit operator T(ConfigVar<T> self)
{
return self._value;
}
}
internal class ConfigHookAttribute : HookAttribute
{
private readonly ConfigEntry<bool> config;
private static readonly List<ConfigVar<bool>> convars = new List<ConfigVar<bool>>();
private static IEnumerable<BaseConVar> convarsHooked
{
[ConVarProvider]
get
{
return (IEnumerable<BaseConVar>)convars;
}
}
internal ConfigHookAttribute(string section, string name, bool defaultValue, string description, Type typeFrom, string methodFrom)
: base(typeFrom, methodFrom)
{
config = MakeConfig(section, name, defaultValue, description);
}
internal ConfigHookAttribute(string section, string name, bool defaultValue, string description, Type typeFrom, string methodFrom, params Type[] parameters)
: base(typeFrom, methodFrom, parameters)
{
config = MakeConfig(section, name, defaultValue, description);
}
private static ConfigEntry<bool> MakeConfig(string section, string name, bool defaultValue, string description)
{
foreach (ConfigVar<bool> convar in convars)
{
if (convar.configEntry != null)
{
ConfigDefinition definition = ((ConfigEntryBase)convar.configEntry).Definition;
if (definition.Key == name && definition.Section == section)
{
return convar.configEntry;
}
}
}
ConfigVar<bool> configVar = new ConfigVar<bool>(section, name, defaultValue, description);
convars.Add(configVar);
return configVar.configEntry;
}
protected override void Hook(MethodInfo from, MethodInfo member)
{
if (config == null)
{
log.error("null config for hook: " + from.Name);
base.Hook(from, member);
}
else
{
config.HookConfig(from, member);
}
}
}
[MeansImplicitUse]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
internal class HookAttribute : Attribute
{
private readonly Type typeFrom;
private readonly string methodFrom;
private readonly Type[] parameters;
protected MethodInfo from
{
get
{
if ((object)typeFrom != null)
{
if (parameters != null)
{
return HookManager.GetMethod(typeFrom, methodFrom, parameters);
}
return HookManager.GetMethod(typeFrom, methodFrom);
}
return null;
}
}
internal HookAttribute(Type typeFrom, string methodFrom)
{
this.typeFrom = typeFrom;
this.methodFrom = methodFrom;
}
internal HookAttribute(Type typeFrom, string methodFrom, params Type[] parameters)
{
this.typeFrom = typeFrom;
this.methodFrom = methodFrom;
this.parameters = parameters;
}
internal HookAttribute()
{
}
internal static void ScanAndApply()
{
ScanAndApply((from a in Assembly.GetExecutingAssembly().GetTypes()
where a.GetCustomAttribute<HookAttribute>() != null
select a).ToArray());
}
internal static void ScanAndApply(params Type[] types)
{
for (int i = 0; i < types.Length; i++)
{
MethodInfo[] methods = types[i].GetMethods(BindingFlags.Static | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
foreach (HookAttribute customAttribute in methodInfo.GetCustomAttributes<HookAttribute>(inherit: false))
{
MethodInfo methodInfo2 = null;
try
{
methodInfo2 = customAttribute.from;
if (methodInfo2 == null && methodInfo.GetParameters().Length == 0)
{
methodInfo.Invoke(null, null);
}
else
{
customAttribute.Hook(methodInfo2, methodInfo);
}
}
catch (Exception e)
{
e.LogHookError(methodInfo2, methodInfo);
}
}
}
}
}
protected virtual void Hook(MethodInfo from, MethodInfo member)
{
IDetour obj = HookManager.ManualDetour(from, member);
if (obj != null)
{
obj.Apply();
}
}
}
internal static class HookManager
{
internal delegate bool ConfigEnabled<T>(T configValue);
private class HookedConfig<T>
{
private readonly ConfigEnabled<T> enabled;
private readonly IDetour detour;
internal HookedConfig(ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, IDetour detour)
{
this.enabled = enabled;
this.detour = detour;
if (configEntry != null)
{
configEntry.SettingChanged += ConfigChanged;
ConfigChanged(configEntry, null);
}
else
{
detour.Apply();
}
}
private void ConfigChanged(object sender, EventArgs args)
{
if (enabled(((ConfigEntry<T>)sender).Value))
{
if (!detour.IsApplied)
{
detour.Apply();
}
}
else if (detour.IsApplied)
{
detour.Undo();
}
}
}
internal const BindingFlags allFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private static readonly ConfigEnabled<bool> boolConfigEnabled = BoolEnabled;
private static ILHookConfig ilHookConfig = new ILHookConfig
{
ManualApply = true
};
private static HookConfig onHookConfig = new HookConfig
{
ManualApply = true
};
internal static void Hook(Type typeFrom, string fromMethod, Manipulator ilHook)
{
Hook(GetMethod(typeFrom, fromMethod), ilHook);
}
internal static void Hook(Delegate fromMethod, Manipulator ilHook)
{
Hook(fromMethod.Method, ilHook);
}
internal static void Hook(MethodBase fromMethod, Manipulator ilHook)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
try
{
new ILHook(fromMethod, ilHook, ref ilHookConfig).Apply();
}
catch (Exception e)
{
e.LogHookError(fromMethod, ((Delegate)(object)ilHook).Method);
}
}
internal static void Hook(Type typeFrom, string fromMethod, Delegate onHook)
{
Hook(GetMethod(typeFrom, fromMethod), onHook.Method, onHook.Target);
}
internal static void Hook(Delegate fromMethod, Delegate onHook)
{
Hook(fromMethod.Method, onHook.Method, onHook.Target);
}
internal static void Hook(MethodBase fromMethod, Delegate onHook)
{
Hook(fromMethod, onHook.Method, onHook.Target);
}
internal static void Hook(MethodBase fromMethod, MethodInfo onHook, object target = null)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
try
{
new Hook(fromMethod, onHook, target, ref onHookConfig).Apply();
}
catch (Exception e)
{
e.LogHookError(fromMethod, onHook);
}
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, Type typeFrom, string fromMethod, Delegate hook)
{
configEntry.HookConfig(boolConfigEnabled, GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, MethodBase fromMethod, Delegate hook)
{
configEntry.HookConfig(boolConfigEnabled, fromMethod, hook.Method, hook.Target);
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, MethodBase fromMethod, MethodInfo hook)
{
configEntry.HookConfig(boolConfigEnabled, fromMethod, hook);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, Type typeFrom, string fromMethod, Delegate hook)
{
configEntry.HookConfig(enabled, GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, MethodBase fromMethod, Delegate hook)
{
configEntry.HookConfig(enabled, fromMethod, hook.Method, hook.Target);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, MethodBase fromMethod, MethodInfo hook, object target = null)
{
try
{
new HookedConfig<T>(configEntry, enabled, ManualDetour(fromMethod, hook, target));
}
catch (Exception e)
{
e.LogHookError(fromMethod, hook);
}
}
internal static IDetour ManualDetour(Type typeFrom, string fromMethod, Delegate hook)
{
return ManualDetour(GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static IDetour ManualDetour(MethodBase fromMethod, Delegate hook)
{
return ManualDetour(fromMethod, hook.Method, hook.Target);
}
internal static IDetour ManualDetour(MethodBase fromMethod, MethodInfo hook, object target = null)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
try
{
ParameterInfo[] parameters = hook.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ILContext))
{
return (IDetour)new ILHook(fromMethod, (Manipulator)hook.CreateDelegate(typeof(Manipulator)), ref ilHookConfig);
}
return (IDetour)new Hook(fromMethod, hook, target, ref onHookConfig);
}
catch (Exception e)
{
e.LogHookError(fromMethod, hook);
return null;
}
}
internal static MethodInfo GetMethod(Type typeFrom, string methodName)
{
if (typeFrom == null || methodName == null)
{
log.error($"Null argument in GetMethod: type={typeFrom}, name={methodName}");
return null;
}
MethodInfo[] array = (from a in typeFrom.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
where a.Name == methodName
select a).ToArray();
switch (array.Length)
{
case 1:
return array[0];
case 0:
log.error($"Failed to find method: {typeFrom}::{methodName}");
return null;
default:
{
string text = $"{array.Length} ambiguous matches found for: {typeFrom}::{methodName}, may be incorrect";
MethodInfo[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
text = text + "\n" + array2[i];
}
log.warning(text);
return array[0];
}
}
}
internal static MethodInfo GetMethod(Type typeFrom, string methodName, params Type[] parameters)
{
if (typeFrom == null || methodName == null)
{
log.error($"Null argument in GetMethod: type={typeFrom}, name={methodName}");
return null;
}
MethodInfo? method = typeFrom.GetMethod(methodName, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, parameters, null);
if (method == null)
{
log.error($"Failed to find method: {typeFrom}::{methodName}_{parameters.Length}");
}
return method;
}
internal static void SetPriority(string[] beforeIL = null, string[] beforeOn = null, string[] afterIL = null, string[] afterOn = null)
{
ilHookConfig.Before = beforeIL;
onHookConfig.Before = beforeOn;
ilHookConfig.After = afterIL;
onHookConfig.After = afterOn;
}
internal static void LogHookError(this Exception e, MethodBase fromMethod, MethodInfo hook)
{
log.error((fromMethod == null) ? $"null from-method for hook: {hook.Name}\n{e}" : $"Failed to hook: {fromMethod.DeclaringType}::{fromMethod.Name} - {hook.Name}\n{e}");
}
private static bool BoolEnabled(bool configValue)
{
return configValue;
}
}
internal static class log
{
private static readonly ManualLogSource logger = Logger.CreateLogSource(Assembly.GetExecutingAssembly().GetName().Name);
[Conditional("DEBUG")]
internal static void debug(object data)
{
logger.LogDebug(data);
}
internal static void info(object data)
{
logger.LogInfo(data);
}
internal static void message(object data)
{
logger.LogMessage(data);
}
internal static void warning(object data)
{
logger.LogWarning(data);
}
internal static void error(object data)
{
logger.LogError(data);
}
internal static void fatal(object data)
{
logger.LogFatal(data);
}
internal static void LogError(this ILCursor c, object data)
{
logger.LogError((object)$"ILCursor failure, skipping: {data}\n{c}");
}
internal static void LogErrorCaller(this ILCursor c, object data)
{
logger.LogError((object)$"ILCursor failed in {new StackFrame(1).GetMethod().Name}, skipping: {data}\n{c}");
}
}
internal static class RiskofOptions
{
internal const string RooGuid = "com.rune580.riskofoptions";
internal static bool enabled => Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void SetSprite(Sprite sprite)
{
ModSettingsManager.SetModIcon(sprite);
}
internal static void SetSpriteDefaultIcon()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
try
{
string fullName = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)).FullName;
Texture2D val = new Texture2D(256, 256);
if (ImageConversion.LoadImage(val, File.ReadAllBytes(Path.Combine(fullName, "icon.png"))))
{
ModSettingsManager.SetModIcon(Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f)));
}
else
{
log.error("Failed to load icon.png");
}
}
catch (Exception ex)
{
log.error("Failed to load icon.png\n" + ex);
}
}
internal static void AddOption(ConfigEntryBase entry)
{
AddOption(entry, string.Empty, string.Empty);
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddOption(ConfigEntryBase entry, string categoryName = "", string name = "", bool restartRequired = false)
{
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Expected O, but got Unknown
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Expected O, but got Unknown
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Expected O, but got Unknown
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Expected O, but got Unknown
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Expected O, but got Unknown
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Expected O, but got Unknown
//IL_00ba: 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_00aa: Expected O, but got Unknown
//IL_00a5: 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_0095: Expected O, but got Unknown
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
Type settingType = entry.SettingType;
object obj;
if (!(settingType == typeof(float)))
{
obj = ((!(settingType == typeof(string))) ? ((!(settingType == typeof(bool))) ? ((!(settingType == typeof(int))) ? ((!(settingType == typeof(Color))) ? ((!(settingType == typeof(KeyboardShortcut))) ? ((object)((!settingType.IsEnum) ? ((ChoiceOption)null) : new ChoiceOption(entry, new ChoiceConfig()))) : ((object)new KeyBindOption((ConfigEntry<KeyboardShortcut>)(object)entry, new KeyBindConfig()))) : ((object)new ColorOption((ConfigEntry<Color>)(object)entry, new ColorOptionConfig()))) : ((object)new IntFieldOption((ConfigEntry<int>)(object)entry, new IntFieldConfig()))) : ((object)new CheckBoxOption((ConfigEntry<bool>)(object)entry, new CheckBoxConfig()))) : ((object)new StringInputFieldOption((ConfigEntry<string>)(object)entry, new InputFieldConfig
{
submitOn = (SubmitEnum)6,
lineType = (LineType)0
})));
}
else if (entry.Description.AcceptableValues is AcceptableValueRange<float>)
{
obj = (object)new SliderOption((ConfigEntry<float>)(object)entry, new SliderConfig
{
min = ((AcceptableValueRange<float>)(object)entry.Description.AcceptableValues).MinValue,
max = ((AcceptableValueRange<float>)(object)entry.Description.AcceptableValues).MaxValue,
FormatString = "{0:f2}",
description = entry.DescWithDefault("{0:f2}")
});
}
else
{
ConfigEntry<float> obj2 = (ConfigEntry<float>)(object)entry;
FloatFieldConfig val = new FloatFieldConfig();
((NumericFieldConfig<float>)val).FormatString = "{0:f2}";
((BaseOptionConfig)val).description = entry.DescWithDefault("{0:f2}");
obj = (object)new FloatFieldOption(obj2, val);
}
BaseOption val2 = (BaseOption)obj;
if (val2 == null)
{
return;
}
BaseOptionConfig config = val2.GetConfig();
config.category = categoryName;
config.name = name;
config.restartRequired = restartRequired;
if (config.description == "")
{
config.description = entry.DescWithDefault();
}
try
{
ModSettingsManager.AddOption(val2);
}
catch (Exception arg)
{
log.error($"AddOption {entry.Definition} failed\n{arg}");
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddOption(ConfigEntry<float> entry, float min, float max, string format = "{0:f2}", string categoryName = "")
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: 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_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new SliderOption(entry, new SliderConfig
{
min = min,
max = max,
FormatString = format,
category = categoryName,
description = ((ConfigEntryBase)(object)entry).DescWithDefault(format)
}));
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddIntSlider(ConfigEntry<int> entry, int min, int max, string categoryName = "")
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: 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_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(entry, new IntSliderConfig
{
min = min,
max = max,
category = categoryName,
description = ((ConfigEntryBase)(object)entry).DescWithDefault()
}));
}
private static string DescWithDefault(this ConfigEntryBase entry, string format = "{0}")
{
return string.Format("{1}\n[Default: " + format + "]", entry.DefaultValue, entry.Description.Description);
}
}
internal class TextHud
{
private static readonly Queue<TextHud> hudsToUpdate;
internal bool resetOnTargetChanged = true;
internal TextAlignmentOptions alignment = (TextAlignmentOptions)257;
internal readonly ConfigEntry<bool> toggleEntry;
private readonly ConfigEntry<int> fontsizeEntry;
private readonly ConfigEntry<Vector2> positionEntry;
private readonly string hudName;
private GameObject objhud;
private HGTextMeshProUGUI textMesh;
private string textToUpdate;
internal static HUD hud
{
get
{
if (HUD.instancesList.Count <= 0)
{
return null;
}
return HUD.instancesList[0];
}
}
internal bool enabled
{
get
{
if (toggleEntry == null)
{
return true;
}
return toggleEntry.Value;
}
}
internal int fontSize
{
get
{
if (fontsizeEntry == null)
{
return -1;
}
return fontsizeEntry.Value;
}
}
internal Vector2 position
{
get
{
//IL_001e: 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)
if (positionEntry == null)
{
return new Vector2(1776.5f, 173f);
}
return positionEntry.Value;
}
}
static TextHud()
{
hudsToUpdate = new Queue<TextHud>();
RoR2Application.onLateUpdate += LateUpdate;
}
private TextHud(ConfigFile configFile, string name, Vector2? defaultPosition, bool? defaultToggle, int? defaultFontSize)
{
//IL_000d: 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)
hudName = name;
if (defaultPosition.HasValue)
{
positionEntry = configFile.Bind<Vector2>(name, "Position", defaultPosition.Value, "Position of " + name + ", starting from bottom left corner");
}
if (defaultToggle.HasValue)
{
toggleEntry = configFile.Bind<bool>(name, "Toggle", defaultToggle.Value, "Toggles " + name);
}
if (defaultFontSize.HasValue)
{
fontsizeEntry = configFile.Bind<int>(name, "Font size", defaultFontSize.Value, "Font size of " + name);
}
DoHooks();
}
internal TextHud(ConfigFile configFile, string name)
: this(configFile, name, null, null, null)
{
}
internal TextHud(ConfigFile configFile, string name, Vector2 defaultPosition)
: this(configFile, name, defaultPosition, null, null)
{
}//IL_0003: Unknown result type (might be due to invalid IL or missing references)
internal TextHud(ConfigFile configFile, string name, Vector2 defaultPosition, bool defaultToggle)
: this(configFile, name, defaultPosition, defaultToggle, null)
{
}//IL_0003: Unknown result type (might be due to invalid IL or missing references)
internal TextHud(ConfigFile configFile, string name, Vector2 defaultPosition, int defaultFontSize)
: this(configFile, name, defaultPosition, null, defaultFontSize)
{
}//IL_0003: Unknown result type (might be due to invalid IL or missing references)
internal TextHud(ConfigFile configFile, string name, Vector2 defaultPosition, bool defaultToggle, int defaultFontSize)
: this(configFile, name, (Vector2?)defaultPosition, (bool?)defaultToggle, (int?)defaultFontSize)
{
}//IL_0003: Unknown result type (might be due to invalid IL or missing references)
internal void UpdateText(string text)
{
if (!hudsToUpdate.Contains(this))
{
hudsToUpdate.Enqueue(this);
}
textToUpdate = text;
}
internal void ClearText()
{
if (Object.op_Implicit((Object)(object)objhud) && !string.IsNullOrEmpty(((TMP_Text)textMesh).text))
{
UpdateText(string.Empty);
}
}
private static void LateUpdate()
{
while (hudsToUpdate.Count > 0)
{
TextHud textHud = hudsToUpdate.Dequeue();
if (textHud.enabled)
{
if ((Object)(object)textHud.objhud == (Object)null)
{
textHud.InitHud();
}
((TMP_Text)textHud.textMesh).SetText(textHud.textToUpdate, true);
}
textHud.textToUpdate = null;
}
}
internal void DestroyHUD()
{
Object.Destroy((Object)(object)objhud);
}
private void InitHud()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: 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)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
objhud = new GameObject(hudName);
RectTransform val = objhud.AddComponent<RectTransform>();
if (Object.op_Implicit((Object)(object)hud))
{
SetTransform(val, hud);
}
val.sizeDelta = Vector2.zero;
val.pivot = new Vector2(0.5f, 0.5f);
val.anchoredPosition = position;
textMesh = objhud.AddComponent<HGTextMeshProUGUI>();
((TMP_Text)textMesh).fontSizeMin = 6f;
if (fontSize >= 0)
{
((TMP_Text)textMesh).fontSize = fontSize;
}
((TMP_Text)textMesh).outlineColor = Color32.op_Implicit(Color.black);
((TMP_Text)textMesh).enableWordWrapping = false;
((TMP_Text)textMesh).alignment = alignment;
}
private void SetTransform(RectTransform textRect, HUD hud)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: 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)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
RectTransform val = (RectTransform)hud.mainUIPanel.transform;
((Transform)textRect).SetParent(hud.mainUIPanel.transform, false);
textRect.anchoredPosition3D = new Vector3(position.x, position.y, 0f - val.anchoredPosition3D.z);
Vector2 anchorMax = (textRect.anchorMin = -val.anchorMin / (val.anchorMax - val.anchorMin));
textRect.anchorMax = anchorMax;
}
private void DoHooks()
{
HUD.onHudTargetChangedGlobal += Reset_OnHudTargetChanged;
if (toggleEntry != null)
{
toggleEntry.SettingChanged += Toggle_Changed;
}
if (positionEntry != null)
{
positionEntry.SettingChanged += Position_Changed;
}
if (fontsizeEntry != null)
{
fontsizeEntry.SettingChanged += FontSize_Changed;
}
}
private void Reset_OnHudTargetChanged(HUD obj)
{
if (Object.op_Implicit((Object)(object)objhud))
{
if (!Object.op_Implicit((Object)(object)objhud.transform.parent))
{
Transform transform = objhud.transform;
SetTransform((RectTransform)(object)((transform is RectTransform) ? transform : null), hud);
}
if (resetOnTargetChanged)
{
ClearText();
}
}
}
private void Toggle_Changed(object sender, EventArgs e)
{
if (Object.op_Implicit((Object)(object)objhud) && !enabled)
{
Object.Destroy((Object)(object)objhud);
}
}
private void Position_Changed(object sender, EventArgs e)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)objhud))
{
objhud.GetComponent<RectTransform>().anchoredPosition = position;
}
}
private void FontSize_Changed(object sender, EventArgs e)
{
if (Object.op_Implicit((Object)(object)objhud) && fontSize > 0)
{
((TMP_Text)textMesh).fontSize = fontSize;
}
}
internal void AddRoOVector2Option()
{
AddRoOVector2Option(hudName);
}
internal void AddRoOVector2Option(string category)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Invalid comparison between Unknown and I4
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
if (RiskofOptions.enabled)
{
new Vector2ScreenOption(positionEntry, hudName + " text", category, new Vector2ScreenOption.DotInfo(((int)alignment == 257) ? new Vector2(0f, 1f) : new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), new Vector2(0.5f, 0.5f), Vector2.op_Implicit(Vector3.zero)), toggleEntry, fontsizeEntry);
}
}
}
}
namespace Dolso.RoO
{
internal class RooSliderInput2 : MonoBehaviour
{
internal UnityEvent<float> onValueChanged = new UnityEvent<float>();
internal string formatString = "F0";
private Slider slider;
private TMP_InputField inputField;
private float _value;
internal float value
{
get
{
return _value;
}
set
{
if (_value != value)
{
_value = value;
onValueChanged.Invoke(_value);
}
UpdateControls();
}
}
private void Awake()
{
slider = ((Component)this).GetComponentInChildren<Slider>();
inputField = ((Component)this).GetComponentInChildren<TMP_InputField>();
((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)SliderChanged);
((UnityEvent<string>)(object)inputField.onEndEdit).AddListener((UnityAction<string>)OnTextEdited);
((UnityEvent<string>)(object)inputField.onSubmit).AddListener((UnityAction<string>)OnTextEdited);
}
internal void Setup(float min, float max)
{
slider.minValue = min;
slider.maxValue = max;
}
internal void SetWholeNumbers(bool wholeNumbers)
{
slider.wholeNumbers = wholeNumbers;
}
private void UpdateControls()
{
if (formatString.StartsWith("F"))
{
slider.value = value;
inputField.text = value.ToString(formatString, CultureInfo.InvariantCulture);
}
else
{
int num = (int)value;
slider.value = num;
inputField.text = num.ToString(formatString, CultureInfo.InvariantCulture);
}
}
private void SliderChanged(float newValue)
{
value = newValue;
}
private void OnTextEdited(string newText)
{
if (float.TryParse(newText, out var result))
{
value = Mathf.Clamp(result, slider.minValue, slider.maxValue);
}
else
{
value = _value;
}
}
}
internal class Vector2ScreenBehaviour : MonoBehaviour
{
private static Sprite checkOn;
private static Sprite checkOff;
private RooSliderInput2 sliderX;
private RooSliderInput2 sliderY;
private RooSliderInput2 sliderSize;
private ChildLocator childLocator;
private RectTransform positionDot;
private RectTransform positionRect;
private Vector2ScreenOption option;
private Image checkBox;
private bool boxState;
private ref readonly Vector2ScreenOption.DotInfo dotinfo => ref option.dotInfo;
private ConfigEntry<Vector2> positionEntry => option.positionEntry;
private ConfigEntry<bool> toggleEntry => option.toggleEntry;
private ConfigEntry<int> fontSizeEntry => option.fontSizeEntry;
private ConfigEntry<float> scaleEntry => option.scaleEntry;
internal static void LoadImages(AsyncOperationHandle<GameObject> handle)
{
CarouselController component = handle.Result.GetComponent<CarouselController>();
checkOn = component.choices[1].customSprite;
checkOff = component.choices[0].customSprite;
}
internal void SetStartingValues(Vector2ScreenOption option)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: 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_0055: 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_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: 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_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
//IL_0263: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Expected O, but got Unknown
//IL_036a: Unknown result type (might be due to invalid IL or missing references)
//IL_036f: Unknown result type (might be due to invalid IL or missing references)
this.option = option;
positionDot.anchorMin = dotinfo.dotAnchor;
positionDot.anchorMax = dotinfo.dotAnchor;
positionDot.pivot = dotinfo.dotAnchor;
positionRect.anchorMin = dotinfo.rectAnchor;
positionRect.anchorMax = dotinfo.rectAnchor;
positionRect.pivot = dotinfo.rectPivot;
positionRect.sizeDelta = dotinfo.rectSize;
Vector2 val = CalcMinMax(1920f, 0);
sliderX = BuildSlider("PositionX", val.x, val.y);
sliderX.formatString = "F0";
sliderX.onValueChanged.AddListener((UnityAction<float>)XChanged);
Vector2 val2 = CalcMinMax(1080f, 1);
sliderY = BuildSlider("PositionY", val2.x, val2.y);
sliderY.formatString = "F0";
sliderY.onValueChanged.AddListener((UnityAction<float>)YChanged);
sliderX.value = positionEntry.Value.x;
sliderY.value = positionEntry.Value.y;
if (toggleEntry != null)
{
boxState = toggleEntry.Value;
((UnityEvent)((Button)((Component)childLocator.FindChild("Toggle")).GetComponent<HGButton>()).onClick).AddListener(new UnityAction(ToggleChanged));
checkBox = ((Component)childLocator.FindChild("ToggleBox")).GetComponent<Image>();
checkBox.sprite = (boxState ? checkOn : checkOff);
}
else
{
((Component)childLocator.FindChild("ToggleParent")).gameObject.SetActive(false);
((Component)childLocator.FindChild("ToggleText")).gameObject.SetActive(false);
RectTransform component = ((Component)childLocator.FindChild("Size")).GetComponent<RectTransform>();
component.anchoredPosition += new Vector2(0f, 66f);
}
if (fontSizeEntry != null)
{
sliderSize = BuildSlider("Size", 5f, option.maxScale);
sliderSize.formatString = "0";
sliderSize.onValueChanged.AddListener((UnityAction<float>)FontSizeChanged);
sliderSize.value = fontSizeEntry.Value;
}
else if (scaleEntry != null)
{
sliderSize = BuildSlider("Size", 0f, option.maxScale);
sliderSize.formatString = "F1";
sliderSize.onValueChanged.AddListener((UnityAction<float>)ScaleChanged);
sliderSize.SetWholeNumbers(wholeNumbers: false);
sliderSize.value = scaleEntry.Value;
}
else
{
((Component)childLocator.FindChild("Size")).gameObject.SetActive(false);
SetSize(option.maxScale * Vector2.one);
}
}
private void Awake()
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Expected O, but got Unknown
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Expected O, but got Unknown
childLocator = ((Component)this).GetComponent<ChildLocator>();
positionDot = ((Component)childLocator.FindChild("PositionDot")).GetComponent<RectTransform>();
positionRect = ((Component)childLocator.FindChild("PositionRect")).GetComponent<RectTransform>();
((UnityEvent)((Button)((Component)childLocator.FindChild("Apply")).GetComponent<HGButton>()).onClick).AddListener(new UnityAction(Apply));
((UnityEvent)((Button)((Component)childLocator.FindChild("Cancel")).GetComponent<HGButton>()).onClick).AddListener(new UnityAction(Close));
((UnityEvent)((Button)((Component)childLocator.FindChild("Default")).GetComponent<HGButton>()).onClick).AddListener(new UnityAction(SetToDefault));
((Component)this).GetComponent<RooEscapeRouter>().escapePressed.AddListener(new UnityAction(Close));
}
private RooSliderInput2 BuildSlider(string childName, float min, float max)
{
RooSliderInput2 rooSliderInput = ((Component)childLocator.FindChild(childName)).gameObject.AddComponent<RooSliderInput2>();
rooSliderInput.Setup(min, max);
return rooSliderInput;
}
private Vector2 CalcMinMax(float length, int index)
{
//IL_0006: 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_001b: 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_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: 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_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
Vector2 val = dotinfo.rectSize;
float num = 0f - ((Vector2)(ref val))[index];
val = dotinfo.dotAnchor;
float num2 = ((Vector2)(ref val))[index];
val = dotinfo.rectPivot;
float num3 = num * (num2 - ((Vector2)(ref val))[index]);
float num4 = 0f - length;
val = dotinfo.rectAnchor;
float num5 = num4 * ((Vector2)(ref val))[index] + num3;
val = dotinfo.rectAnchor;
float num6 = length * (1f - ((Vector2)(ref val))[index]) + num3;
return new Vector2(num5, num6);
}
private void XChanged(float newValue)
{
//IL_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
Vector2 anchoredPosition = positionRect.anchoredPosition;
anchoredPosition.x = newValue;
positionRect.anchoredPosition = anchoredPosition;
}
private void YChanged(float newValue)
{
//IL_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
Vector2 anchoredPosition = positionRect.anchoredPosition;
anchoredPosition.y = newValue;
positionRect.anchoredPosition = anchoredPosition;
}
private void ToggleChanged()
{
boxState = !boxState;
checkBox.sprite = (boxState ? checkOn : checkOff);
}
private void FontSizeChanged(float newValue)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
SetSize(newValue * Vector2.one);
}
private void ScaleChanged(float newValue)
{
//IL_0008: 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)
SetSize(newValue * dotinfo.rectSize);
}
private void SetSize(Vector2 size)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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)
if (((Vector2)(ref size)).sqrMagnitude < 16f)
{
positionDot.sizeDelta = ((Vector2)(ref size)).normalized * 4f;
}
else
{
positionDot.sizeDelta = size;
}
}
private void SetToDefault()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: 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_0028: Unknown result type (might be due to invalid IL or missing references)
Vector2 val = (Vector2)((ConfigEntryBase)positionEntry).DefaultValue;
sliderX.value = val.x;
sliderY.value = val.y;
if (toggleEntry != null)
{
boxState = (bool)((ConfigEntryBase)toggleEntry).DefaultValue;
checkBox.sprite = (boxState ? checkOn : checkOff);
}
if (fontSizeEntry != null)
{
sliderSize.value = (int)((ConfigEntryBase)fontSizeEntry).DefaultValue;
}
else if (scaleEntry != null)
{
sliderSize.value = (float)((ConfigEntryBase)scaleEntry).DefaultValue;
}
}
private void Apply()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
positionEntry.Value = new Vector2((float)Math.Round(sliderX.value, 2), (float)Math.Round(sliderY.value, 2));
if (toggleEntry != null)
{
toggleEntry.Value = boxState;
}
if (fontSizeEntry != null)
{
fontSizeEntry.Value = Mathf.RoundToInt(sliderSize.value);
}
else if (scaleEntry != null)
{
scaleEntry.Value = sliderSize.value;
}
Close();
}
private void Close()
{
Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
}
}
internal class Vector2ScreenOption
{
internal readonly struct DotInfo
{
internal readonly Vector2 dotAnchor;
internal readonly Vector2 rectAnchor;
internal readonly Vector2 rectPivot;
internal readonly Vector2 rectSize;
internal DotInfo(Vector2 dotAnchor, Vector2 rectAnchor, Vector2 rectPivot, Vector2 rectSize)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: 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_0009: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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)
this.dotAnchor = dotAnchor;
this.rectAnchor = rectAnchor;
this.rectPivot = rectPivot;
this.rectSize = rectSize;
}
}
private static GameObject prefab;
internal readonly ConfigEntry<Vector2> positionEntry;
internal readonly ConfigEntry<bool> toggleEntry;
internal readonly ConfigEntry<int> fontSizeEntry;
internal readonly ConfigEntry<float> scaleEntry;
internal readonly DotInfo dotInfo;
internal readonly float maxScale;
internal Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, DotInfo dotInfo, float dotSize = 16f)
: this(positionEntry, ((ConfigEntryBase)positionEntry).Definition.Key, ((ConfigEntryBase)positionEntry).Definition.Section, dotInfo, null, null, null, dotSize)
{
}
internal Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, string name, string category, DotInfo dotInfo, float dotSize = 16f)
: this(positionEntry, name, category, dotInfo, null, null, null, dotSize)
{
}
internal Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, DotInfo dotInfo, ConfigEntry<float> scaleEntry, float maxScale = 3f)
: this(positionEntry, ((ConfigEntryBase)positionEntry).Definition.Key, ((ConfigEntryBase)positionEntry).Definition.Section, dotInfo, null, null, scaleEntry, maxScale)
{
}
internal Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, string name, string category, DotInfo dotInfo, ConfigEntry<float> scaleEntry, float maxScale = 3f)
: this(positionEntry, name, category, dotInfo, null, null, scaleEntry, maxScale)
{
}
internal Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, string name, string category, DotInfo dotInfo, ConfigEntry<bool> toggleEntry = null, ConfigEntry<int> fontSizeEntry = null)
: this(positionEntry, name, category, dotInfo, toggleEntry, fontSizeEntry, null, (fontSizeEntry == null) ? 16 : 36)
{
}
private Vector2ScreenOption(ConfigEntry<Vector2> positionEntry, string name, string category, DotInfo dotInfo, ConfigEntry<bool> toggleEntry, ConfigEntry<int> fontSizeEntry, ConfigEntry<float> scaleEntry, float maxScale)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
this.positionEntry = positionEntry;
this.dotInfo = dotInfo;
this.maxScale = maxScale;
this.toggleEntry = toggleEntry;
this.fontSizeEntry = fontSizeEntry;
this.scaleEntry = scaleEntry;
ModSettingsManager.AddOption((BaseOption)new GenericButtonOption(name, category, "Position of " + name, "Open", new UnityAction(CreateOptionWindow)));
EnsureAssets();
}
internal static void LoadAssets(string assetFolder)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/UI/SettingsEntryButton, Bool.prefab");
val.Completed += Vector2ScreenBehaviour.LoadImages;
if (!Path.IsPathRooted(assetFolder))
{
assetFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), assetFolder, "dolso");
}
AssetBundle obj = AssetBundle.LoadFromFile(assetFolder);
prefab = obj.LoadAsset<GameObject>("TextHud Screen");
obj.Unload(false);
}
private static void EnsureAssets()
{
if (!Object.op_Implicit((Object)(object)prefab))
{
string text = Directory.EnumerateFiles(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "dolso", SearchOption.AllDirectories).FirstOrDefault();
if (text != null)
{
LoadAssets(text);
}
else
{
log.warning("failed to find dolso assetbundle");
}
}
}
private void CreateOptionWindow()
{
Object.Instantiate<GameObject>(prefab).AddComponent<Vector2ScreenBehaviour>().SetStartingValues(this);
}
}
}
namespace ESF
{
internal class CameraModeESF : CameraModePlayerBasic
{
internal static readonly CameraModeESF playerCamera = new CameraModeESF
{
isSpectatorMode = false
};
internal static readonly CameraModeESF spectatorCamera = new CameraModeESF
{
isSpectatorMode = true
};
public override void ApplyLookInputInternal(object rawInstanceData, in CameraModeContext context, in ApplyLookInputArgs input)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
ESFMotor eSFMotor = default(ESFMotor);
if (!context.targetInfo.isViewerControlled || !Object.op_Implicit((Object)(object)context.targetInfo.target) || !context.targetInfo.target.TryGetComponent<ESFMotor>(ref eSFMotor))
{
((CameraModePlayerBasic)this).ApplyLookInputInternal(rawInstanceData, ref context, ref input);
}
else
{
eSFMotor.AccumulateMouseInput(input.lookInput);
}
}
public override void UpdateInternal(object rawInstanceData, in CameraModeContext context, out UpdateResult result)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
//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_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: 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)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
//IL_022b: Unknown result type (might be due to invalid IL or missing references)
//IL_0236: Unknown result type (might be due to invalid IL or missing references)
//IL_0237: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_021f: Unknown result type (might be due to invalid IL or missing references)
//IL_0221: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_0216: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Unknown result type (might be due to invalid IL or missing references)
result = default(UpdateResult);
CameraRigController cameraRigController = context.cameraInfo.cameraRigController;
InstanceData val = (InstanceData)rawInstanceData;
CameraTargetParams targetParams = context.targetInfo.targetParams;
Quaternion val2 = context.cameraInfo.previousCameraState.rotation;
Vector3 position = context.cameraInfo.previousCameraState.position;
CharacterCameraParamsData basic = CharacterCameraParamsData.basic;
basic.fov = BlendableFloat.op_Implicit(val.neutralFov);
float num;
bool flag;
if (Object.op_Implicit((Object)(object)targetParams))
{
CharacterCameraParamsData.Blend(ref targetParams.currentCameraParamsData, ref basic, 1f);
num = basic.fov.value;
flag = targetParams.currentCameraParamsData.isFirstPerson.value;
}
else
{
num = context.cameraInfo.baseFov;
flag = false;
}
val.neutralFov = Mathf.SmoothDamp(val.neutralFov, num, ref val.neutralFovVelocity, 0.2f, float.PositiveInfinity, Time.deltaTime);
Vector3 val3 = CalculateRotatedPivotPosition(in context, flag);
GameObject target = context.targetInfo.target;
if (Object.op_Implicit((Object)(object)target))
{
val2 = target.transform.rotation;
if (!flag && !Config.tpCameraRoll)
{
val2 = Quaternion.LookRotation(val2 * Vector3.forward, Vector3.up);
}
if (!flag)
{
Vector3 val4 = val2 * basic.idealLocalCameraPos.value;
float magnitude = ((Vector3)(ref val4)).magnitude;
float num2 = (1f + Mathf.Clamp(val.pitchYaw.pitch, -90f, 90f) / -90f) * 0.5f;
magnitude *= Mathf.Sqrt(1f - num2);
if (magnitude < 0.25f)
{
magnitude = 0.25f;
}
float num3 = cameraRigController.Raycast(new Ray(val3, val4), magnitude, basic.wallCushion.value - 0.01f);
if (val.currentCameraDistance >= num3)
{
val.currentCameraDistance = num3;
val.cameraDistanceVelocity = 0f;
}
else
{
val.currentCameraDistance = Mathf.SmoothDamp(val.currentCameraDistance, num3, ref val.cameraDistanceVelocity, 0.2f);
}
position = val3 + ((Vector3)(ref val4)).normalized * val.currentCameraDistance;
}
else
{
position = val3;
}
}
result.cameraState.position = position;
result.cameraState.rotation = val2;
result.cameraState.fov = num;
result.showSprintParticles = false;
result.firstPersonTarget = null;
result.showDisabledSkillsParticles = context.targetInfo.skillsAreDisabled;
result.showSecondaryElectricityParticles = context.targetInfo.showSecondaryElectricity;
((CameraModePlayerBasic)this).UpdateCrosshair(rawInstanceData, ref context, ref result.cameraState, ref val3, ref result.crosshairWorldPosition);
}
private static Vector3 CalculateRotatedPivotPosition(in CameraModeContext context, bool firstPerson)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: 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_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
CameraRigController cameraRigController = context.cameraInfo.cameraRigController;
CameraTargetParams targetParams = context.targetInfo.targetParams;
Vector3 result = context.cameraInfo.previousCameraState.position;
if (Object.op_Implicit((Object)(object)targetParams))
{
Vector3 position = ((Component)targetParams).transform.position;
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(0f, targetParams.currentCameraParamsData.pivotVerticalOffset.value, 0f);
if (!firstPerson && (bool)Config.tpCameraRoll && Object.op_Implicit((Object)(object)context.targetInfo.target))
{
val = context.targetInfo.target.transform.rotation * val;
}
Vector3 val2 = (Object.op_Implicit((Object)(object)targetParams.cameraPivotTransform) ? targetParams.cameraPivotTransform.position : position) + val;
if (targetParams.dontRaycastToPivot)
{
result = val2;
}
else
{
Vector3 val3 = val2 - position;
float magnitude = ((Vector3)(ref val3)).magnitude;
Ray val4 = default(Ray);
((Ray)(ref val4))..ctor(position, val3);
float num = cameraRigController.Raycast(val4, magnitude, targetParams.currentCameraParamsData.wallCushion.value);
result = ((Ray)(ref val4)).GetPoint(num);
}
}
return result;
}
public override void CollectLookInputInternal(object rawInstanceData, in CameraModeContext context, out CollectLookInputResult output)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
((CameraModePlayerBasic)this).CollectLookInputInternal(rawInstanceData, ref context, ref output);
if (context.targetInfo.isSprinting && CameraRigController.enableSprintSensitivitySlowdown.value)
{
ref Vector2 lookInput = ref output.lookInput;
lookInput *= 2f;
}
}
}
internal static class Config
{
internal static readonly ConfigVar<bool> swapYawRoll = new ConfigVar<bool>("Camera", "Swap Yaw and Roll", defaultValue: false, "If enabled, horizontal mouse will apply yaw, and strafe keys will roll");
internal static readonly ConfigVar<bool> scopeToggle = new ConfigVar<bool>("Camera", "Scope Toggle", defaultValue: true, "If scope should be a toggle instead of a hold");
internal static readonly ConfigVar<bool> tpCameraRoll = new ConfigVar<bool>("Camera", "Third Person Camera Roll", defaultValue: false, "If the third person camera should be affected by roll");
internal static void DoConfig(ConfigFile configFile)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
configFile.Bind<string>("", "Version", "1", "");
ESFController.textHud = new TextHud(configFile, "ESF Text", new Vector2(600f, 500f), defaultToggle: true, 16);
ESFController.oobText = new TextHud(configFile, "Out of Bounds", new Vector2(960f, 720f), defaultToggle: true, 64)
{
alignment = (TextAlignmentOptions)514
};
if (RiskofOptions.enabled)
{
DoRiskOfOptions();
}
}
private static void DoRiskOfOptions()
{
Vector2ScreenOption.LoadAssets("Assets");
ESFController.textHud.AddRoOVector2Option();
ESFController.oobText.AddRoOVector2Option();
}
[ConCommand(/*Could not decode attribute arguments.*/)]
private static void ReloadConfig(ConCommandArgs args)
{
Utilities.configFile.Reload();
Debug.Log((object)"Reloaded ESF config");
}
}
internal class Content : IContentPackProvider
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static BankCallback <>9__9_0;
internal void <LoadSoundbankAsync>b__9_0(uint id, IntPtr ptr, AKRESULT akResult, object cookie)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if ((int)akResult != 1)
{
log.error(string.Format("Error loading bank: {0}, Error code: {1}", "ESFSoundbank.bnk", akResult));
}
}
}
private static AssetBundle assetBundle;
internal static ContentPack contentPack;
public string identifier => "dolso.ESF";
private static string directory => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets");
public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
{
AssetBundleCreateRequest assetBundleRequest = AssetBundle.LoadFromFileAsync(Path.Combine(directory, "esfassets"));
yield return LoadAsync((AsyncOperation)(object)assetBundleRequest, args);
assetBundle = assetBundleRequest.assetBundle;
AssetBundleRequest serializableContentPack = assetBundle.LoadAssetAsync<SerializableContentPack>("ESF ContentPack");
yield return LoadAsync((AsyncOperation)(object)serializableContentPack, args);
contentPack = ((SerializableContentPack)serializableContentPack.asset).CreateContentPack();
LoadSoundbankAsync();
yield return DoBody();
yield return DoNoseguns();
yield return DoVelocityBomb();
yield return DoHornetMissile();
if (RiskofOptions.enabled)
{
yield return DoRiskOfOptions();
}
static IEnumerator LoadAsync(AsyncOperation request, LoadStaticContentAsyncArgs args)
{
while (!request.isDone)
{
args.ReportProgress(request.progress);
yield return null;
}
}
}
public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
{
ContentPack.Copy(contentPack, args.output);
yield break;
}
public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
{
yield break;
}
private static void LoadSoundbankAsync()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: 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_000d: Invalid comparison between Unknown and I4
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//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_0033: Expected O, but got Unknown
AKRESULT val = AkSoundEngine.AddBasePath(directory);
if ((int)val == 1)
{
object obj = <>c.<>9__9_0;
if (obj == null)
{
BankCallback val2 = delegate(uint id, IntPtr ptr, AKRESULT akResult, object cookie)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if ((int)akResult != 1)
{
log.error(string.Format("Error loading bank: {0}, Error code: {1}", "ESFSoundbank.bnk", akResult));
}
};
<>c.<>9__9_0 = val2;
obj = (object)val2;
}
AkBankManager.LoadBankAsync("ESFSoundbank.bnk", (BankCallback)obj);
}
else
{
log.error($"Error adding base path: {directory}, Error code: {val}");
}
}
private static IEnumerator DoBody()
{
AsyncOperationHandle<GameObject> effect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/UI/StandardCrosshair.prefab");
AsyncOperationHandle<Shader> cloudshader = Addressables.LoadAssetAsync<Shader>((object)"RoR2/Base/Shaders/HGIntersectionCloudRemap.shader");
AssetBundleRequest matphase = assetBundle.LoadAssetAsync<Material>("matPhaseJump-Stubbed");
yield return effect;
yield return cloudshader;
yield return matphase;
contentPack.bodyPrefabs.Find("ESFBody").GetComponent<CharacterBody>()._defaultCrosshairPrefab = effect.Result;
((Material)matphase.asset).shader = cloudshader.Result;
}
private static IEnumerator DoNoseguns()
{
AsyncOperationHandle<GameObject> explosion = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/OmniExplosionVFXQuick.prefab");
AsyncOperationHandle<GameObject> muzzle = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/Muzzleflash1.prefab");
AsyncOperationHandle<GameObject> tracer = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Commando/TracerCommandoDefault.prefab");
AsyncOperationHandle<GameObject> hiteffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Bandit2/HitsparkBandit.prefab");
yield return explosion;
yield return muzzle;
yield return tracer;
yield return hiteffect;
Banshee.blastEffectPrefab = explosion.Result;
Banshee.tracerPrefab = Utilities.CreatePrefab(tracer.Result, "ESF Tracer");
Banshee.tracerPrefab.AddComponent<VFXAttributes>().vfxPriority = (VFXPriority)1;
EntityStateConfiguration stateConfig = contentPack.entityStateConfigurations.Find("ESF.EntityStates.AirHammer");
stateConfig.ModifyStateConfig("muzzleFlashPrefab", muzzle.Result);
stateConfig.ModifyStateConfig("tracerEffectPrefab", Banshee.tracerPrefab);
AirHammer.blastEffectPrefab = Utilities.CreatePrefab(explosion.Result, "AirHammerExplosion");
AirHammer.blastEffectPrefab.GetComponent<EffectComponent>().soundName = "dolso_esf_airhammer_explosion";
ScytheLaserFire.hitEffectPrefab = Utilities.CreatePrefab(hiteffect.Result, "Saron HitEffect");
ParticleSystemRenderer component = ((Component)ScytheLaserFire.hitEffectPrefab.transform.Find("Particles/HitFlash")).GetComponent<ParticleSystemRenderer>();
ColorOverLifetimeModule colorOverLifetime = ((Component)component).GetComponent<ParticleSystem>().colorOverLifetime;
((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(new Color(161f, 0f, 143f), new Color(114f, 0f, 200f));
((Renderer)component).material = new Material(((Renderer)component).material);
((Renderer)component).material.SetFloat("_Boost", 1f);
((Renderer)component).material.SetFloat("_AlphaBoost", 1f);
ScytheLaserFire.tracerPrefab = contentPack.effectDefs.Find("TracerScythe").prefab;
Material val = new Material(((Renderer)tracer.Result.GetComponent<LineRenderer>()).material);
((Renderer)ScytheLaserFire.tracerPrefab.GetComponent<LineRenderer>()).material = val;
val.EnableKeyword("_DisableRemapOn");
contentPack.effectDefs.Add((EffectDef[])(object)new EffectDef[3]
{
new EffectDef(Banshee.tracerPrefab),
new EffectDef(AirHammer.blastEffectPrefab),
new EffectDef(ScytheLaserFire.hitEffectPrefab)
});
}
private static IEnumerator DoVelocityBomb()
{
AsyncOperationHandle<GameObject> effect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/FallBoots/BootShockwave.prefab");
yield return effect;
GameObject val = Utilities.CreatePrefab(effect.Result, "VelocityBombShockwave");
SizeOverLifetimeModule sizeOverLifetime = ((Component)val.transform.Find("Sphere")).GetComponent<ParticleSystem>().sizeOverLifetime;
MinMaxCurve size = ((SizeOverLifetimeModule)(ref sizeOverLifetime)).size;
((MinMaxCurve)(ref size)).curve.keys = (Keyframe[])(object)new Keyframe[2]
{
new Keyframe(0f, 0f),
new Keyframe(0.006f, 1f)
};
((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = size;
contentPack.projectilePrefabs.Find("VelocityBomb").GetComponent<ProjectileExplosion>().explosionEffect = val;
contentPack.effectDefs.Add((EffectDef[])(object)new EffectDef[1]
{
new EffectDef(val)
});
}
private static IEnumerator DoHornetMissile()
{
AsyncOperationHandle<GameObject> explosion = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/OmniExplosionVFXQuick.prefab");
yield return explosion;
HornetMissile component = contentPack.projectilePrefabs.Find("Esf_HornetProjectile").GetComponent<HornetMissile>();
component.explosion_effect = Utilities.CreatePrefab(explosion.Result, "HornetExplosion");
component.explosion_effect.GetComponent<EffectComponent>().soundName = "dolso_esf_explo_blast_small";
contentPack.effectDefs.Add((EffectDef[])(object)new EffectDef[1]
{
new EffectDef(component.explosion_effect)
});
}
private static IEnumerator DoRiskOfOptions()
{
AssetBundleRequest sprite = assetBundle.LoadAssetAsync<Sprite>("ESFIcon");
yield return sprite;
Object asset = sprite.asset;
RiskofOptions.SetSprite((Sprite)(object)((asset is Sprite) ? asset : null));
}
}
[CreateAssetMenu(menuName = "Dolso/ESF/CrosshairSkillDef")]
internal class CrosshairSkillDef : SkillDef
{
private class InstanceData : BaseSkillInstanceData
{
internal OverrideRequest crosshair_override_request;
}
[SerializeField]
private GameObject crosshair_prefab;
public override BaseSkillInstanceData OnAssigned(GenericSkill skillSlot)
{
return (BaseSkillInstanceData)(object)new InstanceData
{
crosshair_override_request = CrosshairUtils.RequestOverrideForBody(skillSlot.characterBody, crosshair_prefab, (OverridePriority)0)
};
}
public override void OnUnassigned(GenericSkill skillSlot)
{
InstanceData obj = skillSlot.skillInstanceData as InstanceData;
if (obj != null)
{
obj.crosshair_override_request.Dispose();
}
}
}
[CreateAssetMenu(menuName = "Dolso/ESF/FuelSkillDef")]
internal class FuelSkillDef : SkillDef
{
public class InstanceData : BaseSkillInstanceData
{
public ESFFuel esfFuel;
}
[Flags]
public enum FuelProviderType
{
None = 0,
Main = 3,
ForBonusOnly = 0xC,
Base = 1,
CapacityAllStock = 2,
CapacityBonusOnly = 4,
IgnoreFuelUsage = 8
}
[Header("Fuel")]
public float activationCost;
public float thresholdMult;
public FuelProviderType fuelType;
public override BaseSkillInstanceData OnAssigned(GenericSkill skillSlot)
{
return (BaseSkillInstanceData)(object)new InstanceData
{
esfFuel = ((Component)skillSlot).GetComponent<ESFFuel>()
};
}
public override bool IsReady(GenericSkill skillSlot)
{
if (((SkillDef)this).IsReady(skillSlot))
{
if ((fuelType & FuelProviderType.IgnoreFuelUsage) <= FuelProviderType.None)
{
return ((InstanceData)(object)skillSlot.skillInstanceData).esfFuel.fuelCurrent >= thresholdMult * activationCost;
}
return true;
}
return false;
}
public override void OnExecute([NotNull] GenericSkill skillSlot)
{
((SkillDef)this).OnExecute(skillSlot);
if ((fuelType & FuelProviderType.IgnoreFuelUsage) == 0)
{
((InstanceData)(object)skillSlot.skillInstanceData).esfFuel.TryConsumeFuel(activationCost);
}
}
}
internal static class Hooks
{
[Hook(typeof(MapZone), "TeleportBody")]
private static void DelayTeleportion_IL_MapZone_TeleportBody(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt(a, typeof(Physics), "GetIgnoreLayerCollision")
}))
{
val.Emit(OpCodes.Ldarg_0);
val.Emit(OpCodes.Ldarg_1);
val.EmitDelegate<Func<bool, MapZone, CharacterBody, bool>>((Func<bool, MapZone, CharacterBody, bool>)delegate(bool ignore, MapZone mapZone, CharacterBody body)
{
//IL_0006: 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)
if (ignore)
{
return true;
}
ESFController eSFController = default(ESFController);
return body.bodyIndex == Plugin.bodyIndex && ((Component)body).TryGetComponent<ESFController>(ref eSFController) && !eSFController.ShouldOobTeleport(mapZone);
});
}
else
{
val.LogErrorCaller("GetIgnoreLayerCollision");
}
}
[Hook(typeof(GenericSkill), "CanApplyAmmoPack")]
private static bool Bandolier_On_GenericSkill_CanApplyAmmoPack(Func<GenericSkill, bool> orig, GenericSkill self)
{
if (self.skillInstanceData is FuelSkillDef.InstanceData instanceData)
{
instanceData.esfFuel.RefillFuel();
return false;
}
return orig(self);
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("dolso.ESF", "ESF", "1.3.0")]
public class Plugin : BaseUnityPlugin
{
public const string ModGuid = "dolso.ESF";
public const string Version = "1.3.0";
public static BodyIndex bodyIndex { get; private set; }
private void Awake()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
Utilities.Awake((BaseUnityPlugin)(object)this);
((ResourceAvailability)(ref BodyCatalog.availability)).CallWhenAvailable((Action)SetBodyIndex);
Config.DoConfig(((BaseUnityPlugin)this).Config);
HookAttribute.ScanAndApply(typeof(Hooks));
ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(CollectContentPack);
Language.collectLanguageRootFolders += CollectLanguageFolder;
LoadBurst();
}
private void LoadBurst()
{
string location = Assembly.GetExecutingAssembly().Location;
location = location.Insert(location.Length - 4, ".Bursted");
if (!File.Exists(location))
{
log.error("Missing " + Path.GetFileName(location));
}
else if (!BurstRuntime.LoadAdditionalLibrary(location))
{
log.error("Failed to load bursted assembly");
}
}
private static void CollectContentPack(AddContentPackProviderDelegate addContentPackProvider)
{
addContentPackProvider.Invoke((IContentPackProvider)(object)new Content());
}
private void CollectLanguageFolder(List<string> list)
{
list.Add(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Language"));
}
private static void SetBodyIndex()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
bodyIndex = BodyCatalog.FindBodyIndex("ESFBody");
}
internal static ProcChainMask RollBleedMask(float bleedChance, CharacterMaster master)
{
//IL_0002: 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)
ProcChainMask result = default(ProcChainMask);
if (!Util.CheckRoll(bleedChance, master))
{
((ProcChainMask)(ref result)).AddProc((ProcType)5);
}
return result;
}
}
}
namespace ESF.EntityStates
{
internal class Afterburn : BaseSkillState
{
public static string soundLoopBegin;
public static string soundLoopStop;
[SerializeField]
public float burnDuration;
private ESFController esf;
public override void OnEnter()
{
((BaseState)this).OnEnter();
esf = ((EntityState)this).gameObject.GetComponent<ESFController>();
esf.motor.boosting = true;
if (NetworkServer.active && ((EntityState)this).characterBody.inventory.GetItemCountEffective(Items.IncreasePrimaryDamage) > 0)
{
((EntityState)this).characterBody.AddIncreasePrimaryDamageStack();
}
AkSoundEngine.PostEvent(esf.boostSound, ((EntityState)this).gameObject);
}
public override void OnExit()
{
esf.motor.boosting = false;
AkSoundEngine.PostEvent(esf.boostSoundStop, ((EntityState)this).gameObject);
((EntityState)this).OnExit();
}
public override void FixedUpdate()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
((EntityState)this).FixedUpdate();
if (((EntityState)this).isAuthority)
{
ESFFuel esfFuel = ((FuelSkillDef.InstanceData)(object)((BaseSkillState)this).activatorSkillSlot.skillInstanceData).esfFuel;
if (!((BaseSkillState)this).IsKeyDownAuthority() || ((EntityState)this).characterBody.HasBuff(Buffs.DisableAllSkills.buffIndex) || !esfFuel.TryConsumeFuel(esfFuel.baseRechargeTime / burnDuration * Time.deltaTime))
{
((EntityState)this).outer.SetNextStateToMain();
}
}
}
public override InterruptPriority GetMinimumInterruptPriority()
{
return (InterruptPriority)1;
}
}
internal class AimBomb : BaseSkillState
{
[BurstCompile]
private struct CalcPathJob : IJob
{
private readonly float3 v0;
private readonly float3 x0;
private readonly float m;
private readonly float dt;
private NativeArray<float3> pathPositions;
internal CalcPathJob(Vector3 initialPosition, Vector3 velocity, float antiGravCoef, NativeArray<Vector3> pathPositions)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: 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_0013: 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_0032: Unknown result type (might be due to invalid IL or missing references)
x0 = float3.op_Implicit(initialPosition);
v0 = float3.op_Implicit(velocity);
m = antiGravCoef;
dt = Time.fixedDeltaTime;
this.pathPositions = pathPositions.Reinterpret<float3>();
}
public void Execute()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//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_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)
//IL_001d: 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)
//IL_0023: 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_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: 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_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//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_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
float3 val = v0;
float3 zero = float3.zero;
float3 val2 = float3.op_Implicit(dt * Physics.gravity);
float y = Physics.gravity.y;
pathPositions[0] = x0;
for (int i = 1; i < pathPositions.Length; i++)
{
if (val.y < 0f)
{
zero.y = dt * m * math.max(y, val.y);
val += val2 - zero;
}
else
{
val += val2;
}
pathPositions[i] = pathPositions[i - 1] + val * dt;
}
}
}
private static readonly ConfigVar<float> bombDaamge = new ConfigVar<float>("bomb", "damage", 22f);
public static string bombBayString;
[SerializeField]
public GameObject projectilePrefab;
[SerializeField]
public float rearmTime;
[SerializeField]
public float antiGravCoef;
[SerializeField]
public static GameObject lineRendererPrefab;
private LineRenderer arcLineRenderer;
private Transform bombBay;
private NativeArray<Vector3> arcPathPositions;
private JobHandle arcHandle;
public override void OnEnter()
{
((BaseState)this).OnEnter();
if (((EntityState)this).isAuthority)
{
RoR2Application.onLateUpdate += LateUpdate;
arcLineRenderer = Object.Instantiate<GameObject>(lineRendererPrefab).GetComponent<LineRenderer>();
bombBay = ((Component)((EntityState)this).modelLocator.modelTransform).GetComponent<ChildLocator>().FindChild(bombBayString);
}
}
public override void OnExit()
{
if (((EntityState)this).isAuthority)
{
RoR2Application.onLateUpdate -= LateUpdate;
EntityState.Destroy((Object)(object)arcLineRenderer);
((JobHandle)(ref arcHandle)).Complete();
if (arcPathPositions.IsCreated)
{
arcPathPositions.Dispose();
}
}
((EntityState)this).OnExit();
}
public override void Update()
{
//IL_001c: 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_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: 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_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
((EntityState)this).Update();
if (((EntityState)this).isAuthority)
{
arcPathPositions = new NativeArray<Vector3>(arcLineRenderer.positionCount, (Allocator)3, (NativeArrayOptions)1);
arcHandle = IJobExtensions.Schedule<CalcPathJob>(new CalcPathJob(bombBay.position, ((EntityState)this).rigidbody.velocity - ((EntityState)this).transform.up, antiGravCoef, arcPathPositions), default(JobHandle));
}
}
private void LateUpdate()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
if (arcPathPositions.IsCreated)
{
((JobHandle)(ref arcHandle)).Complete();
arcLineRenderer.SetPositions(arcPathPositions);
arcPathPositions.Dispose();
}
}
public override void FixedUpdate()
{
//IL_002f: 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_005c: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
((EntityState)this).FixedUpdate();
if (((EntityState)this).isAuthority && !((BaseSkillState)this).IsKeyDownAuthority())
{
((BaseSkillState)this).activatorSkillSlot.DeductStock(2);
ProjectileManager.instance.FireProjectile(new FireProjectileInfo
{
projectilePrefab = projectilePrefab,
position = bombBay.position,
rotation = bombBay.rotation,
owner = ((EntityState)this).gameObject,
damage = ((BaseState)this).damageStat * (float)bombDaamge,
force = 100f,
crit = ((BaseState)this).RollCrit()
});
((EntityState)this).outer.SetNextStateToMain();
}
}
public override InterruptPriority GetMinimumInterruptPriority()
{
return (InterruptPriority)1;
}
}
internal class AirHammer : GenericBulletBaseState
{
private static readonly ConfigVar<float> bleedChance = new ConfigVar<float>("airham", "bleedChance", 60f);
internal static GameObject blastEffectPrefab;
[SerializeField]
public float blastRadius;
private BlastAttack blastAttack;
public override void OnEnter()
{
//IL_0021: 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)
//IL_003e: 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_0051: 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)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Expected O, but got Unknown
ESFController component = ((EntityState)this).gameObject.GetComponent<ESFController>();
base.muzzleName = component.muzzleName;
if (((EntityState)this).isAuthority)
{
blastAttack = new BlastAttack
{
baseForce = base.force,
radius = blastRadius,
attacker = ((EntityState)this).gameObject,
teamIndex = ((EntityState)this).teamComponent.teamIndex,
procCoefficient = 1f,
damageColorIndex = (DamageColorIndex)0,
falloffModel = (FalloffModel)1,
damageType = DamageTypeCombo.GenericPrimary,
attackerFiltering = (AttackerFiltering)2
};
}
((GenericBulletBaseState)this).OnEnter();
}
public override void ModifyBullet(BulletAttack bulletAttack)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//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)
bulletAttack.hitCallback = new HitCallback(HitCallback);
bulletAttack.damageType = DamageTypeCombo.GenericPrimary;
}
private bool HitCallback(BulletAttack bulletAttack, ref BulletHit hitInfo)
{
//IL_0025: 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_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: 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_0065: Expected O, but got Unknown
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: 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)
int num;
if (Object.op_Implicit((Object)(object)hitInfo.collider))
{
num = ((((1 << ((Component)hitInfo.collider).gameObject.layer) & LayerMask.op_Implicit(bulletAttack.stopperMask)) != 0) ? 1 : 0);
if (num != 0)
{
EffectManager.SpawnEffect(blastEffectPrefab, new EffectData
{
origin = hitInfo.point,
scale = blastRadius
}, true);
blastAttack.baseDamage = (0.25f + 0.75f * Mathf.Clamp01(Mathf.InverseLerp(25f, 5f, hitInfo.distance))) * bulletAttack.damage;
blastAttack.crit = bulletAttack.isCrit;
blastAttack.procChainMask = Plugin.RollBleedMask(bleedChance, ((EntityState)this).characterBody.master);
blastAttack.position = hitInfo.point;
blastAttack.Fire();
}
}
else
{
num = 0;
}
return num == 0;
}
public override InterruptPriority GetMinimumInterruptPriority()
{
return (InterruptPriority)2;
}
}
internal class Banshee : BaseSkillState
{
private static readonly ConfigVar<float> damage = new ConfigVar<float>("banshee", "damage", 0.935f);
private static readonly ConfigVar<float> baseAttackInterval = new ConfigVar<float>("banshee", "baseAttackInterval", 0.075f);
private static readonly ConfigVar<float> bleedChance = new ConfigVar<float>("banshee", "bleedChance", 60f);
private static readonly ConfigVar<float> spread = new ConfigVar<float>("banshee", "spread", 4f);
private static readonly ConfigVar<float> blastRadius = new ConfigVar<float>("banshee", "radius", 4f);
internal static GameObject blastEffectPrefab;
internal static GameObject tracerPrefab;
public static string soundLoopBegin;
public static string soundLoopStop;
private float attackInterval;
private float attackTimer;
private uint playingID;
private BulletAttack bulletAttack;
private BlastAttack blastAttack;
public override void OnEnter()
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: 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_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due
