using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using Microsoft.CodeAnalysis;
using MysteryDice;
using MysteryDice.Effects;
using MysteryDice.Patches;
using UnityEngine;
using com.github.zehsteam.TwitchChatAPI;
using com.github.zehsteam.TwitchChatAPI.Objects;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DiceTwitchIntegration")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Twitch Integration for The Dice Mod")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DiceTwitchIntegration")]
[assembly: AssemblyTitle("DiceTwitchIntegration")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace DiceTwitchIntegration
{
public class ConfigManager
{
public static void SetupLethalConfig()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Expected O, but got Unknown
BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(TwitchHandler.enableSubs);
IntInputFieldConfigItem val2 = new IntInputFieldConfigItem(TwitchHandler.cheerMin);
IntInputFieldConfigItem val3 = new IntInputFieldConfigItem(TwitchHandler.cheerGood);
IntInputFieldConfigItem val4 = new IntInputFieldConfigItem(TwitchHandler.cheerAwful);
IntInputFieldConfigItem val5 = new IntInputFieldConfigItem(TwitchHandler.cheerGreat);
IntInputFieldConfigItem val6 = new IntInputFieldConfigItem(TwitchHandler.cheerMixed);
IntInputFieldConfigItem val7 = new IntInputFieldConfigItem(TwitchHandler.cheerBad);
BoolCheckBoxConfigItem val8 = new BoolCheckBoxConfigItem(TwitchHandler.enableCheer);
BoolCheckBoxConfigItem val9 = new BoolCheckBoxConfigItem(TwitchHandler.enableRaid);
BoolCheckBoxConfigItem val10 = new BoolCheckBoxConfigItem(TwitchHandler.enableChatEvents);
IntInputFieldConfigItem val11 = new IntInputFieldConfigItem(TwitchHandler.chattersMin);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val5);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val7);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val9);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val11);
}
}
[BepInPlugin("Slayer6409.DiceTwitchIntegration", "Dice Twitch Integration", "0.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
private const string modGUID = "Slayer6409.DiceTwitchIntegration";
private const string modName = "Dice Twitch Integration";
private const string modVersion = "0.0.1";
public static ConfigFile BepInExConfig;
private readonly Harmony harmony = new Harmony("Slayer6409.DiceTwitchIntegration");
public static ManualLogSource CustomLogger;
public static bool LethalConfigPresent;
private void Awake()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
{
LethalConfigPresent = true;
}
BepInExConfig = new ConfigFile(Path.Combine(Paths.ConfigPath, "Emergency Dice Twitch.cfg"), true);
CustomLogger = Logger.CreateLogSource("Slayer6409.DiceTwitchIntegration");
((BaseUnityPlugin)this).Logger.LogInfo((object)"Dice Twitch Integration has been loaded!");
TwitchHandler.doConfigStuff();
TwitchHandler.Initialize();
harmony.PatchAll();
if (LethalConfigPresent)
{
ConfigManager.SetupLethalConfig();
}
}
}
public class TwitchHandler
{
public static ConfigEntry<bool> enableSubs;
public static ConfigEntry<bool> enableCheer;
public static ConfigEntry<int> cheerMin;
public static ConfigEntry<int> cheerGood;
public static ConfigEntry<int> cheerGreat;
public static ConfigEntry<int> cheerAwful;
public static ConfigEntry<int> cheerBad;
public static ConfigEntry<int> cheerMixed;
public static ConfigEntry<bool> enableRaid;
public static ConfigEntry<bool> enableChatEvents;
public static ConfigEntry<int> chattersMin;
public static HashSet<string> evnt = new HashSet<string>();
public static bool hasRan = false;
public static void Initialize()
{
try
{
API.OnMessage += OnMessageHandler;
API.OnCheer += OnCheerHandler;
API.OnSub += OnSubHandler;
API.OnRaid += OnRaidHandler;
Application.quitting += delegate
{
API.OnMessage -= OnMessageHandler;
API.OnCheer -= OnCheerHandler;
API.OnSub -= OnSubHandler;
API.OnRaid -= OnRaidHandler;
};
}
catch (Exception arg)
{
Plugin.CustomLogger.LogError((object)$"Failed to initialize TwitchIntegrationManager. {arg}");
}
}
public static void doConfigStuff()
{
enableSubs = Plugin.BepInExConfig.Bind<bool>("Twitch", "Enable Sub", true, "If Twitch Subscription events are enabled");
enableCheer = Plugin.BepInExConfig.Bind<bool>("Twitch", "Enable Cheer", true, "If Twitch Cheer events are enabled");
enableChatEvents = Plugin.BepInExConfig.Bind<bool>("Twitch", "Enable Chat Events", true, "If Twitch Chat events are enabled ");
chattersMin = Plugin.BepInExConfig.Bind<int>("Twitch", "Chatters Min", 5, "How many Chatters are required for an event to start");
enableRaid = Plugin.BepInExConfig.Bind<bool>("Twitch", "Enable Raids", true, "If Twitch Raid events are enabled (Experimental so off by default)");
cheerMin = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Min", 50, "How many bits required before a dice event is triggered");
cheerGreat = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Great", 1, "The ones digit for spawning a Great Effect");
cheerGood = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Good", 2, "The ones digit for spawning a Good Effect");
cheerMixed = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Mixed", 3, "The ones digit for spawning a Mixed Effect");
cheerBad = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Bad", 4, "The ones digit for spawning a Bad Effect");
cheerAwful = Plugin.BepInExConfig.Bind<int>("Twitch", "Cheer Awful", 5, "The ones digit for spawning a Awful Effect");
}
public static void OnMessageHandler(TwitchMessage message)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
TwitchUser user = ((TwitchMessage)(ref message)).User;
if (((TwitchUser)(ref user)).Username == "slayer6409")
{
string text = ((TwitchMessage)(ref message)).Message.ToUpper();
if (((TwitchMessage)(ref message)).Message.ToUpper().Contains("RANDOM") && ((TwitchMessage)(ref message)).Message.ToUpper().Contains("DICE"))
{
if (text.Contains("GOOD"))
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)3, "twitch");
}
else if (text.Contains("BAD"))
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)1, "twitch");
}
else if (text.Contains("AWFUL"))
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)0, "twitch");
}
else if (text.Contains("GREAT"))
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)4, "twitch");
}
else if (text.Contains("MIXED"))
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)2, "twitch");
}
else
{
Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch");
}
}
else if (((TwitchMessage)(ref message)).Message.ToUpper() == "SUPERTEST")
{
Test();
}
}
if (enableChatEvents.Value && ((TwitchMessage)(ref message)).Message.ToUpper().StartsWith("!EVENT"))
{
Debug.Log((object)"test");
if (evnt.Count == 0)
{
Misc.SafeTipMessage("Dice Twitch event started", $"{chattersMin.Value - 1} more users needed to trigger an event! Do !event to join the event!");
}
HashSet<string> hashSet = evnt;
user = ((TwitchMessage)(ref message)).User;
hashSet.Add(((TwitchUser)(ref user)).Username);
if (evnt.Count >= chattersMin.Value && !hasRan)
{
((MonoBehaviour)StartOfRound.Instance).StartCoroutine(waitReset());
}
}
}
public static IEnumerator waitReset()
{
hasRan = true;
Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch chatters:");
yield return (object)new WaitForSeconds(120f);
evnt = new HashSet<string>();
hasRan = false;
}
public static void Test()
{
Misc.SpawnEnemyForced(GetEnemies.Lasso, 4, true, false);
}
private static void OnSubHandler(TwitchSubEvent subEvent)
{
//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_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Invalid comparison between Unknown and I4
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Invalid comparison between Unknown and I4
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Invalid comparison between Unknown and I4
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Invalid comparison between Unknown and I4
if (enableSubs.Value)
{
TwitchUser user = ((TwitchEvent)subEvent).User;
string displayName = ((TwitchUser)(ref user)).DisplayName;
int num = 0;
if ((int)subEvent.Tier == 1)
{
num = 1;
}
else if ((int)subEvent.Tier == 2)
{
num = 2;
}
else if ((int)subEvent.Tier == 3)
{
num = 3;
}
if ((int)subEvent.SubType == 3)
{
num *= subEvent.GiftCount;
}
for (int i = 0; i < num; i++)
{
Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
}
}
}
private static void OnCheerHandler(TwitchCheerEvent cheerEvent)
{
//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)
TwitchUser user = ((TwitchEvent)cheerEvent).User;
string displayName = ((TwitchUser)(ref user)).DisplayName;
if (enableCheer.Value && cheerEvent.CheerAmount >= cheerMin.Value)
{
int num = cheerEvent.CheerAmount % 10;
if (num == cheerAwful.Value)
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)0, displayName);
}
else if (num == cheerGood.Value)
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)3, displayName);
}
else if (num == cheerGreat.Value)
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)4, displayName);
}
else if (num == cheerBad.Value)
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)1, displayName);
}
else if (num == cheerMixed.Value)
{
Networker.Instance.QueueSelectTypeServerRPC((EffectType)2, displayName);
}
else
{
Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
}
}
}
private static void OnRaidHandler(TwitchRaidEvent raidEvent)
{
//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)
TwitchUser user = ((TwitchEvent)raidEvent).User;
string displayName = ((TwitchUser)(ref user)).DisplayName;
if (enableRaid.Value)
{
int num = raidEvent.ViewerCount / 5;
if (num > 5)
{
num = 5;
}
for (int i = 0; i < num; i++)
{
Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
}
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "DiceTwitchIntegration";
public const string PLUGIN_NAME = "DiceTwitchIntegration";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
