using System;
using System.Collections;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Newtonsoft.Json;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ThunderRain")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a5527a08b16ccc0b7e46663fa8936728948d1470")]
[assembly: AssemblyProduct("ThunderRain")]
[assembly: AssemblyTitle("ThunderRain")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ThunderRain;
internal static class ConfigManager
{
internal static ConfigEntry<int> TimeSpanSeconds;
internal static ConfigEntry<DeviceManager.ShockerSelection> ShockerSelection;
internal static ConfigFile OptionsConfig { get; set; }
internal static ConfigEntry<string> PiShockUsername { get; set; }
internal static ConfigEntry<string> PiShockApiKey { get; set; }
internal static ConfigEntry<string> PiShockShareCodes { get; set; }
internal static ConfigEntry<bool> VibrationsFromDealingDamage { get; set; }
internal static ConfigEntry<bool> VibrationsFromReceivingDamage { get; set; }
internal static ConfigEntry<bool> ShocksFromDealingDamage { get; set; }
internal static ConfigEntry<bool> ShocksFromReceivingDamage { get; set; }
internal static ConfigEntry<bool> VibrationsFromMinionsDealingDamage { get; set; }
internal static ConfigEntry<bool> VibrationsFromMinionsReceivingDamage { get; set; }
internal static ConfigEntry<bool> ShocksFromMinionsDealingDamage { get; set; }
internal static ConfigEntry<bool> ShocksFromMinionsReceivingDamage { get; set; }
internal static ConfigEntry<bool> ShockOnDeath { get; set; }
internal static ConfigEntry<int> BaseVibrationDurationSeconds { get; set; }
internal static ConfigEntry<int> BaseShockDurationSeconds { get; set; }
internal static ConfigEntry<int> DealingDamageBaseVibrationIntensity { get; set; }
internal static ConfigEntry<int> DealingDamageBaseShockIntensity { get; set; }
internal static ConfigEntry<int> ReceivingDamageBaseVibrationIntensity { get; set; }
internal static ConfigEntry<int> ReceivingDamageBaseShockIntensity { get; set; }
internal static ConfigEntry<int> MaximumVibrationIntensity { get; set; }
internal static ConfigEntry<int> MaximumShockIntensity { get; set; }
internal static ConfigEntry<int> MaximumVibrationDuration { get; set; }
internal static ConfigEntry<int> MaximumShockDuration { get; set; }
internal static ConfigEntry<int> ShockOnDeathIntensity { get; set; }
internal static ConfigEntry<int> ShockOnDeathDuration { get; set; }
internal static ConfigEntry<bool> AllowExcessDamage { get; set; }
static ConfigManager()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Expected O, but got Unknown
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Expected O, but got Unknown
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Expected O, but got Unknown
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Expected O, but got Unknown
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Expected O, but got Unknown
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Expected O, but got Unknown
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Expected O, but got Unknown
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_01ce: Expected O, but got Unknown
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_01fc: Expected O, but got Unknown
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Expected O, but got Unknown
//IL_024e: Unknown result type (might be due to invalid IL or missing references)
//IL_0258: Expected O, but got Unknown
//IL_027a: Unknown result type (might be due to invalid IL or missing references)
//IL_0284: Expected O, but got Unknown
//IL_028e: Unknown result type (might be due to invalid IL or missing references)
//IL_0298: Expected O, but got Unknown
//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
//IL_02c4: Expected O, but got Unknown
//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
//IL_02d8: Expected O, but got Unknown
//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0304: Expected O, but got Unknown
//IL_030e: Unknown result type (might be due to invalid IL or missing references)
//IL_0318: Expected O, but got Unknown
//IL_033a: Unknown result type (might be due to invalid IL or missing references)
//IL_0344: Expected O, but got Unknown
//IL_034e: Unknown result type (might be due to invalid IL or missing references)
//IL_0358: Expected O, but got Unknown
//IL_037a: Unknown result type (might be due to invalid IL or missing references)
//IL_0384: Expected O, but got Unknown
//IL_038e: Unknown result type (might be due to invalid IL or missing references)
//IL_0398: Expected O, but got Unknown
//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
//IL_03c4: Expected O, but got Unknown
//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
//IL_03d8: Expected O, but got Unknown
//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0405: Expected O, but got Unknown
//IL_040f: Unknown result type (might be due to invalid IL or missing references)
//IL_0419: Expected O, but got Unknown
//IL_043c: Unknown result type (might be due to invalid IL or missing references)
//IL_0446: Expected O, but got Unknown
//IL_0450: Unknown result type (might be due to invalid IL or missing references)
//IL_045a: Expected O, but got Unknown
//IL_047d: Unknown result type (might be due to invalid IL or missing references)
//IL_0487: Expected O, but got Unknown
//IL_0491: Unknown result type (might be due to invalid IL or missing references)
//IL_049b: Expected O, but got Unknown
//IL_04be: Unknown result type (might be due to invalid IL or missing references)
//IL_04c8: Expected O, but got Unknown
//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
//IL_04dc: Expected O, but got Unknown
//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0508: Expected O, but got Unknown
//IL_0512: Unknown result type (might be due to invalid IL or missing references)
//IL_051c: Expected O, but got Unknown
//IL_053e: Unknown result type (might be due to invalid IL or missing references)
//IL_0548: Expected O, but got Unknown
//IL_0552: Unknown result type (might be due to invalid IL or missing references)
//IL_055c: Expected O, but got Unknown
//IL_057e: Unknown result type (might be due to invalid IL or missing references)
//IL_0588: Expected O, but got Unknown
//IL_0592: Unknown result type (might be due to invalid IL or missing references)
//IL_059c: Expected O, but got Unknown
//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
//IL_05ca: Expected O, but got Unknown
//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
//IL_05f8: Expected O, but got Unknown
OptionsConfig = new ConfigFile(Paths.ConfigPath + "\\ThunderRain.cfg", true);
ModSettingsManager.SetModDescription("Shocks PiShocks in response to in-game damage events.");
PiShockUsername = OptionsConfig.Bind<string>("PiShock Info", "PiShock Username", "", "Your PiShock username.");
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(PiShockUsername));
PiShockApiKey = OptionsConfig.Bind<string>("PiShock Info", "PiShock API Key", "", "Generated at https://pishock.com/#/account.");
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(PiShockApiKey));
PiShockShareCodes = OptionsConfig.Bind<string>("PiShock Info", "PiShock Share Code", "", "Share code generated on PiShock control panel. Separate each code with a comma.");
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(PiShockShareCodes));
VibrationsFromDealingDamage = OptionsConfig.Bind<bool>("Activated By", "Vibrations from Dealing Damage", false, "Generate vibrations when dealing damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(VibrationsFromDealingDamage));
VibrationsFromReceivingDamage = OptionsConfig.Bind<bool>("Activated By", "Vibrations from Receiving Damage", true, "Generate vibrations when receiving damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(VibrationsFromReceivingDamage));
ShocksFromDealingDamage = OptionsConfig.Bind<bool>("Activated By", "Shocks from Dealing Damage", false, "Generate shocks when dealing damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShocksFromDealingDamage));
ShocksFromReceivingDamage = OptionsConfig.Bind<bool>("Activated By", "Shocks from Receiving Damage", false, "Generate shocks when receiving damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShocksFromReceivingDamage));
VibrationsFromMinionsDealingDamage = OptionsConfig.Bind<bool>("Activated By", "Vibrations from Minions Dealing Damage", false, "Generate vibrations when your minions (drones, turrets, etc.) deal damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(VibrationsFromMinionsDealingDamage));
VibrationsFromMinionsReceivingDamage = OptionsConfig.Bind<bool>("Activated By", "Vibrations from Minions Receiving Damage", false, "Generate vibrations when your minions (drones, turrets, etc.) receive damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(VibrationsFromMinionsReceivingDamage));
ShocksFromMinionsDealingDamage = OptionsConfig.Bind<bool>("Activated By", "Shocks from Minions Dealing Damage", false, "Generate shocks when your minions (drones, turrets, etc.) deal damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShocksFromMinionsDealingDamage));
ShocksFromMinionsReceivingDamage = OptionsConfig.Bind<bool>("Activated By", "Shocks from Minions Receiving Damage", false, "Generate shocks when your minions (drones, turrets, etc.) receive damage.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShocksFromMinionsReceivingDamage));
ShockOnDeath = OptionsConfig.Bind<bool>("Activated By", "Shock on Death", false, "Get shocked on death.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShockOnDeath));
BaseVibrationDurationSeconds = OptionsConfig.Bind<int>("Operation Values", "Base Vibration Duration in Seconds", 1, new ConfigDescription("The base vibration duration in seconds to add when damage is dealt or received. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(BaseVibrationDurationSeconds));
BaseShockDurationSeconds = OptionsConfig.Bind<int>("Operation Values", "Base Shock Duration in Seconds", 1, new ConfigDescription("The base shock duration in seconds to add when damage is dealt or received. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(BaseShockDurationSeconds));
DealingDamageBaseVibrationIntensity = OptionsConfig.Bind<int>("Operation Values", "Base Vibration Intensity on Damage Dealt", 1, new ConfigDescription("The base vibration intensity for vibrations generated by dealing damage. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(DealingDamageBaseVibrationIntensity));
DealingDamageBaseShockIntensity = OptionsConfig.Bind<int>("Operation Values", "Base Shock Intensity on Damage Dealt", 1, new ConfigDescription("The base shock intensity for shocks generated by dealing damage. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(DealingDamageBaseShockIntensity));
ReceivingDamageBaseVibrationIntensity = OptionsConfig.Bind<int>("Operation Values", "Base Vibration Intensity on Damage Received", 1, new ConfigDescription("The base vibration intensity for vibrations generated by receiving damage. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(ReceivingDamageBaseVibrationIntensity));
ReceivingDamageBaseShockIntensity = OptionsConfig.Bind<int>("Operation Values", "Base Shock Intensity on Damage Received", 1, new ConfigDescription("The base shock intensity for shocks generated by receiving damage. Multiplied by (damageDealt / maxHealthOfDamagedEntity).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(ReceivingDamageBaseShockIntensity));
MaximumVibrationIntensity = OptionsConfig.Bind<int>("Operation Values", "Maximum Vibration Intensity", 100, new ConfigDescription("The maximum vibration intensity for a single operation.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaximumVibrationIntensity));
MaximumShockIntensity = OptionsConfig.Bind<int>("Operation Values", "Maximum Shock Intensity", 100, new ConfigDescription("The maximum shock intensity for a single operation.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaximumShockIntensity));
MaximumVibrationDuration = OptionsConfig.Bind<int>("Operation Values", "Maximum Vibration Duration Seconds", 15, new ConfigDescription("The maximum shock duration for a single operation in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaximumVibrationDuration));
MaximumShockDuration = OptionsConfig.Bind<int>("Operation Values", "Maximum Shock Duration Seconds", 15, new ConfigDescription("The maximum shock duration for a single operation in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(MaximumShockDuration));
ShockOnDeathIntensity = OptionsConfig.Bind<int>("Operation Values", "Shock on Death Intensity", 0, new ConfigDescription("Intensity of shock to receive on death independent of other calculations. Still subject to configured maximum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(ShockOnDeathIntensity));
ShockOnDeathDuration = OptionsConfig.Bind<int>("Operation Values", "Shock on Death Duration Seconds", 0, new ConfigDescription("Duration of shock to receive on death independent of other calculations. Still subject to configured maximum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(ShockOnDeathDuration));
TimeSpanSeconds = OptionsConfig.Bind<int>("Operation Behavior", "Time Span", 3, new ConfigDescription("Sums up values over this many seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(TimeSpanSeconds));
ShockerSelection = OptionsConfig.Bind<DeviceManager.ShockerSelection>("Operation Behavior", "Shocker Selection", DeviceManager.ShockerSelection.Random, "Controls which shockers are selected when commands are sent.");
ModSettingsManager.AddOption((BaseOption)new ChoiceOption((ConfigEntryBase)(object)ShockerSelection));
AllowExcessDamage = OptionsConfig.Bind<bool>("Operation Behavior", "Allow For Excess Damage", false, "Allow for excess damage dealt over an entity's max combined health to affect operation intensity.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(AllowExcessDamage));
}
}
internal class DeviceManager
{
internal enum ShockerSelection
{
All,
Random
}
private const string PiShockApiUri = "https://do.pishock.com/api/apioperate/";
private static readonly HttpClient HttpClient = new HttpClient
{
BaseAddress = new Uri("https://do.pishock.com/api/apioperate/")
};
internal string DisplayName { get; private set; }
private PiShockShocker[] Shockers { get; set; }
public DeviceManager(string displayName)
{
DisplayName = displayName;
UpdateShockerList(null, null);
ConfigManager.PiShockShareCodes.SettingChanged += UpdateShockerList;
}
private void UpdateShockerList(object _, EventArgs __)
{
Log.Info(ConfigManager.PiShockShareCodes.Value);
Shockers = (from code in ConfigManager.PiShockShareCodes.Value.Split(',')
select new PiShockShocker(code.Trim())).ToArray();
Log.Info($"Amount of shockers: {Shockers.Length}");
PiShockShocker[] shockers = Shockers;
foreach (PiShockShocker piShockShocker in shockers)
{
Log.Info("Shocker share code: " + piShockShocker.ShareCode);
}
}
private PiShockShocker GetRandomShocker()
{
return Shockers[new Random().Next(0, Shockers.Length)];
}
internal void ProcessValuePool(ValuePool pool)
{
if (!pool.VibrationValues.IsNill())
{
Operate(PiShockOperation.Vibrate, pool.VibrationValues);
}
if (!pool.ShockValues.IsNill())
{
Operate(PiShockOperation.Shock, pool.ShockValues);
}
}
private void Operate(PiShockOperation operation, PiShockValues values)
{
switch (ConfigManager.ShockerSelection.Value)
{
case ShockerSelection.All:
{
PiShockShocker[] shockers = Shockers;
foreach (PiShockShocker shocker in shockers)
{
SendOperation(operation, values, shocker);
}
break;
}
case ShockerSelection.Random:
SendOperation(operation, values, GetRandomShocker());
break;
}
}
private async void SendOperation(PiShockOperation operation, PiShockValues values, PiShockShocker shocker)
{
Log.Info($"Sending {operation} with {values} to {shocker.ShareCode}");
HttpContent content = new StringContent(JsonConvert.SerializeObject((object)new PiShockRequest
{
Username = ConfigManager.PiShockUsername.Value,
ApiKey = ConfigManager.PiShockApiKey.Value,
Code = shocker.ShareCode,
Name = DisplayName,
Operation = (int)operation,
DurationSeconds = (int)values.Duration.TotalSeconds,
Intensity = (int)values.Intensity
}), Encoding.UTF8, "application/json");
string text = await (await HttpClient.PostAsync("", content)).Content.ReadAsStringAsync();
if (!(text == "Operation Succeeded.") && !(text == "Operation Attempted."))
{
Log.Error("Request failed for reason: " + text);
}
}
}
internal static class Log
{
private static ManualLogSource Logger { get; set; }
internal static void Init(ManualLogSource logger)
{
Logger = logger;
}
[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 enum PiShockOperation
{
Shock,
Vibrate,
Beep
}
internal class PiShockRequest
{
[JsonProperty("Username")]
internal string Username { get; set; }
[JsonProperty("Apikey")]
internal string ApiKey { get; set; }
[JsonProperty("Code")]
internal string Code { get; set; }
[JsonProperty("Name")]
internal string Name { get; set; }
[JsonProperty("Op")]
internal int Operation { get; set; }
[JsonProperty("Duration")]
internal int DurationSeconds { get; set; }
[JsonProperty("Intensity")]
internal int Intensity { get; set; }
}
internal class PiShockShocker
{
internal string ShareCode { get; set; }
internal PiShockShocker(string shareCode)
{
ShareCode = shareCode;
}
}
internal class PiShockValues
{
internal const int MaxApiDurationSeconds = 15;
internal const int MaxApiIntensity = 100;
private TimeSpan _duration = TimeSpan.Zero;
private float _intensity;
private int MaxIntensity { get; set; }
private TimeSpan MaxDuration { get; set; }
internal TimeSpan Duration
{
get
{
return _duration;
}
set
{
float num = Mathf.Clamp((float)value.TotalSeconds, 0f, (float)MaxDuration.TotalSeconds);
_duration = TimeSpan.FromSeconds(num);
}
}
internal float Intensity
{
get
{
return _intensity;
}
set
{
_intensity = Mathf.Clamp(value, 0f, (float)MaxIntensity);
}
}
internal PiShockValues(int maxIntensity, int maxDurationSeconds)
{
MaxIntensity = maxIntensity;
MaxDuration = TimeSpan.FromSeconds(maxDurationSeconds);
}
internal PiShockValues()
: this(100, 15)
{
}
internal bool IsNill()
{
bool num = Duration.TotalSeconds < 1.0;
bool flag = Intensity < 1f;
return num || flag;
}
public override string ToString()
{
return $"PiShockValues(Intensity={Intensity}, Duration={Duration.TotalSeconds}s)";
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[BepInPlugin("quasikyo.ThunderRain", "ThunderRain", "1.1.1")]
public class ThunderRain : BaseUnityPlugin
{
public const string PluginGUID = "quasikyo.ThunderRain";
public const string PluginAuthor = "quasikyo";
public const string PluginName = "ThunderRain";
public const string PluginVersion = "1.1.1";
private static ValuePool Buffer { get; set; }
private static DeviceManager DeviceManager { get; set; }
public void Awake()
{
Log.Init(((BaseUnityPlugin)this).Logger);
Log.Info("Performing setup for ThunderRain");
Buffer = new ValuePool();
DeviceManager = new DeviceManager("ThunderRain");
GlobalEventManager.onClientDamageNotified += OperateDevicesOnDamage;
GlobalEventManager.onCharacterDeathGlobal += OperateDevicesOnDeath;
}
private void OperateDevicesOnDeath(DamageReport report)
{
if (ConfigManager.ShockOnDeath.Value && !((Object)(object)LocalUserManager.GetFirstLocalUser().cachedMaster.GetBody() != (Object)(object)report.victimBody))
{
ValuePool valuePool = new ValuePool();
valuePool.ShockValues.Intensity = ConfigManager.ShockOnDeathIntensity.Value;
valuePool.ShockValues.Duration = TimeSpan.FromSeconds(ConfigManager.ShockOnDeathDuration.Value);
DeviceManager.ProcessValuePool(valuePool);
}
}
private IEnumerator ReadBuffer()
{
Buffer.SetActive();
yield return (object)new WaitForSeconds((float)ConfigManager.TimeSpanSeconds.Value);
DeviceManager.ProcessValuePool(Buffer);
Buffer.Reset();
}
private void OperateDevicesOnDamage(DamageDealtMessage damageMessage)
{
CharacterMaster cachedMaster = LocalUserManager.GetFirstLocalUser().cachedMaster;
CharacterBody body = cachedMaster.GetBody();
GameObject victim = damageMessage.victim;
CharacterBody val = ((victim != null) ? victim.GetComponent<CharacterBody>() : null);
GameObject attacker = damageMessage.attacker;
CharacterBody val2 = ((attacker != null) ? attacker.GetComponent<CharacterBody>() : null);
if (!((Object)(object)val == (Object)null))
{
if (Buffer.Status == ValuePool.PoolStatus.Empty)
{
((MonoBehaviour)this).StartCoroutine(ReadBuffer());
}
float fullCombinedHealth = val.healthComponent.fullCombinedHealth;
float num = damageMessage.damage / fullCombinedHealth;
if (!ConfigManager.AllowExcessDamage.Value)
{
num = Math.Min(num, 1f);
}
bool flag = (Object)(object)body == (Object)(object)val2;
bool num2 = (Object)(object)body == (Object)(object)val;
object obj;
if (val2 == null)
{
obj = null;
}
else
{
CharacterMaster master = val2.master;
obj = ((master != null) ? master.minionOwnership.ownerMaster : null);
}
bool flag2 = (Object)obj == (Object)(object)cachedMaster;
CharacterMaster master2 = val.master;
bool flag3 = (Object)(object)((master2 != null) ? master2.minionOwnership.ownerMaster : null) == (Object)(object)cachedMaster;
if ((flag && ConfigManager.VibrationsFromDealingDamage.Value) || (flag2 && ConfigManager.VibrationsFromMinionsDealingDamage.Value))
{
Buffer.VibrationValues.Duration += TimeSpan.FromSeconds((float)ConfigManager.BaseVibrationDurationSeconds.Value * num);
Buffer.VibrationValues.Intensity += (float)ConfigManager.DealingDamageBaseVibrationIntensity.Value * num;
}
if ((flag && ConfigManager.ShocksFromDealingDamage.Value) || (flag2 && ConfigManager.ShocksFromMinionsDealingDamage.Value))
{
Buffer.ShockValues.Duration += TimeSpan.FromSeconds((float)ConfigManager.BaseShockDurationSeconds.Value * num);
Buffer.ShockValues.Intensity += (float)ConfigManager.DealingDamageBaseShockIntensity.Value * num;
}
if ((num2 && ConfigManager.VibrationsFromReceivingDamage.Value) || (flag3 && ConfigManager.VibrationsFromMinionsReceivingDamage.Value))
{
Buffer.VibrationValues.Duration += TimeSpan.FromSeconds((float)ConfigManager.BaseVibrationDurationSeconds.Value * num);
Buffer.VibrationValues.Intensity += (float)ConfigManager.ReceivingDamageBaseVibrationIntensity.Value * num;
}
if ((num2 && ConfigManager.ShocksFromReceivingDamage.Value) || (flag3 && ConfigManager.ShocksFromMinionsReceivingDamage.Value))
{
Buffer.ShockValues.Duration += TimeSpan.FromSeconds((float)ConfigManager.BaseShockDurationSeconds.Value * num);
Buffer.ShockValues.Intensity += (float)ConfigManager.ReceivingDamageBaseShockIntensity.Value * num;
}
}
}
}
internal class ValuePool
{
internal enum PoolStatus
{
Empty,
Active
}
internal PoolStatus Status { get; private set; }
internal PiShockValues VibrationValues { get; set; }
internal PiShockValues ShockValues { get; set; }
internal ValuePool()
{
Reset();
ConfigManager.MaximumShockDuration.SettingChanged += ResetOnSettingChange;
ConfigManager.MaximumShockIntensity.SettingChanged += ResetOnSettingChange;
ConfigManager.MaximumVibrationDuration.SettingChanged += ResetOnSettingChange;
ConfigManager.MaximumVibrationIntensity.SettingChanged += ResetOnSettingChange;
}
internal void SetActive()
{
Status = PoolStatus.Active;
}
private void ResetOnSettingChange(object sender, EventArgs e)
{
Reset();
}
internal void Reset()
{
Status = PoolStatus.Empty;
VibrationValues = new PiShockValues(ConfigManager.MaximumVibrationIntensity.Value, ConfigManager.MaximumVibrationDuration.Value);
ShockValues = new PiShockValues(ConfigManager.MaximumShockIntensity.Value, ConfigManager.MaximumShockDuration.Value);
}
}
