using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using DrawNCards;
using HarmonyLib;
using Photon.Pun;
using SelectAnyNumberRounds;
using TMPro;
using UnboundLib;
using UnboundLib.GameModes;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LarrysMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a534b58fb3870dcff127e8ee485d0c757e867a8d")]
[assembly: AssemblyProduct("LarrysMod")]
[assembly: AssemblyTitle("LarrysMod")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace System
{
internal class Func
{
private Player player;
private CardInfo card;
private bool v;
public Func(Player player, CardInfo card, bool v)
{
this.player = player;
this.card = card;
this.v = v;
}
}
}
namespace LarrysMod
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("larppaliz.rounds.settingsmod", "Larrys Mod", "1.0.0")]
[BepInProcess("Rounds.exe")]
public class LarrysMod : BaseUnityPlugin
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__18_0;
public static UnityAction<bool> <>9__22_0;
public static UnityAction<float> <>9__22_1;
public static UnityAction<float> <>9__22_2;
public static UnityAction<float> <>9__22_3;
internal void <Start>b__18_0()
{
}
internal void <BreadGUI>b__22_0(bool value)
{
EnableWinnerDrawLessConfig.Value = value;
enableWinnerDrawLess = value;
}
internal void <BreadGUI>b__22_1(float value)
{
WinnerDrawAmountConfig.Value = (int)value;
winnerDrawAmount = (int)value;
}
internal void <BreadGUI>b__22_2(float value)
{
StartingPicksConfig.Value = (int)value;
StartingPicks = (int)value;
}
internal void <BreadGUI>b__22_3(float value)
{
StartingDrawsConfig.Value = (int)value;
StartingDraws = (int)value;
}
}
[CompilerGenerated]
private sealed class <FirstRoundStart>d__30 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
private List<Player>.Enumerator <>s__1;
private Player <player>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <FirstRoundStart>d__30(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__1 = default(List<Player>.Enumerator);
<player>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
<>s__1 = PlayerManager.instance.players.GetEnumerator();
try
{
while (<>s__1.MoveNext())
{
<player>5__2 = <>s__1.Current;
DrawNCards.RPCA_SetPickerDraws(<player>5__2.playerID, DrawNCards.GetPickerDraws(<player>5__2.playerID) - StartingDraws);
<player>5__2 = null;
}
}
finally
{
((IDisposable)<>s__1).Dispose();
}
<>s__1 = default(List<Player>.Enumerator);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <GameEnd>d__29 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GameEnd>d__29(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
Plugin.configPickNumber.Value = 2;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <GameStart>d__31 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
private int <i>5__1;
private Player <player>5__2;
private List<Player>.Enumerator <>s__3;
private Player <player>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GameStart>d__31(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<player>5__2 = null;
<>s__3 = default(List<Player>.Enumerator);
<player>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
<i>5__1 = 0;
while (<i>5__1 < PlayerManager.instance.players.Count)
{
<player>5__2 = PlayerManager.instance.players[<i>5__1];
<player>5__2.playerID = <i>5__1;
<player>5__2 = null;
<i>5__1++;
}
Plugin.enableContinueCard.Value = false;
Plugin.configPickNumber.Value = StartingPicks;
<>s__3 = PlayerManager.instance.players.GetEnumerator();
try
{
while (<>s__3.MoveNext())
{
<player>5__4 = <>s__3.Current;
DrawNCards.RPCA_SetPickerDraws(<player>5__4.playerID, DrawNCards.NumDraws + StartingDraws);
<player>5__4 = null;
}
}
finally
{
((IDisposable)<>s__3).Dispose();
}
<>s__3 = default(List<Player>.Enumerator);
GameModeManager.AddOnceHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)<>4__this.FirstRoundStart);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PickEnd>d__27 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
private int <i>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PickEnd>d__27(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
Plugin.configPickNumber.Value = 1;
<i>5__1 = 0;
while (<i>5__1 < PlayerManager.instance.players.Count)
{
if (<>4__this.PlayersItsDonefor != null && PlayerManager.instance.players != null && <>4__this.PlayersItsDonefor.Count() > 1)
{
<>4__this.fixWinnerDrawThing(PlayerManager.instance.players[<i>5__1]);
}
<i>5__1++;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PickStart>d__28 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PickStart>d__28(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <RoundEnd>d__25 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IGameModeHandler gm;
public LarrysMod <>4__this;
private List<int> <winners>5__1;
private List<Player>.Enumerator <>s__2;
private Player <player>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RoundEnd>d__25(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<winners>5__1 = null;
<>s__2 = default(List<Player>.Enumerator);
<player>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
<>4__this.PlayersItsDonefor = (Player[])(object)new Player[50];
<winners>5__1 = <>4__this.GetRoundWinners();
if (EnableWinnerDrawLessConfig.Value && <winners>5__1 != null && DrawNCards.NumDrawsConfig != null)
{
<>s__2 = PlayerManager.instance.players.GetEnumerator();
try
{
while (<>s__2.MoveNext())
{
<player>5__3 = <>s__2.Current;
if (<winners>5__1.Contains(<player>5__3.teamID))
{
<>4__this.WinnerDraws[<player>5__3.playerID] = DrawNCards.GetPickerDraws(<player>5__3.playerID);
DrawNCards.RPCA_SetPickerDraws(<player>5__3.playerID, winnerDrawAmount + (DrawNCards.GetPickerDraws(<player>5__3.playerID) - DrawNCards.NumDraws));
}
<player>5__3 = null;
}
}
finally
{
((IDisposable)<>s__2).Dispose();
}
<>s__2 = default(List<Player>.Enumerator);
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string ModId = "larppaliz.rounds.settingsmod";
private const string ModName = "Larrys Mod";
public const string Version = "1.0.0";
public const string ModInitials = "LM";
public static ConfigEntry<bool> EnableWinnerDrawLessConfig;
public static ConfigEntry<int> WinnerDrawAmountConfig;
public static ConfigEntry<int> StartingPicksConfig;
public static int StartingPicks = 1;
public static ConfigEntry<int> StartingDrawsConfig;
public static int StartingDraws = 0;
public static bool enableWinnerDrawLess = false;
public static int winnerDrawAmount = 2;
public GameObject optionsMenu;
public int[] WinnerDraws = new int[50];
public Player[] PlayersItsDonefor;
public static LarrysMod instance { get; private set; }
private void Awake()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
instance = this;
Harmony val = new Harmony("larppaliz.rounds.settingsmod");
val.PatchAll();
GameModeManager.AddHook("PickEnd", (Func<IGameModeHandler, IEnumerator>)PickEnd);
GameModeManager.AddHook("PickStart", (Func<IGameModeHandler, IEnumerator>)PickStart);
GameModeManager.AddHook("RoundEnd", (Func<IGameModeHandler, IEnumerator>)RoundEnd);
GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
EnableWinnerDrawLessConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("LM", "WinnerDrawToggle", false, "Toggle the winner draw stuff.");
WinnerDrawAmountConfig = ((BaseUnityPlugin)this).Config.Bind<int>("LM", "WinnerDrawAmount", 2, "Winner Draw Amount");
StartingPicksConfig = ((BaseUnityPlugin)this).Config.Bind<int>("LM", "StartingPicksAmount", 1, "Starting Picks Amount");
StartingDrawsConfig = ((BaseUnityPlugin)this).Config.Bind<int>("LM", "StartingDrawsAmount", 0, "Extra Starting Draws Amount");
}
private void Start()
{
//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_003c: Expected O, but got Unknown
Unbound.RegisterHandshake("larppaliz.rounds.settingsmod", (Action)OnHandShakeCompleted);
object obj = <>c.<>9__18_0;
if (obj == null)
{
UnityAction val = delegate
{
};
<>c.<>9__18_0 = val;
obj = (object)val;
}
Unbound.RegisterMenu("Larrys Mod", (UnityAction)obj, (Action<GameObject>)BreadGUI, optionsMenu, false);
StartingPicks = StartingPicksConfig.Value;
StartingDraws = StartingDrawsConfig.Value;
enableWinnerDrawLess = EnableWinnerDrawLessConfig.Value;
winnerDrawAmount = WinnerDrawAmountConfig.Value;
}
public List<int> GetRoundWinners()
{
return new List<int>(GameModeManager.CurrentHandler.GetRoundWinners());
}
internal void OnHandShakeCompleted()
{
if (PhotonNetwork.IsMasterClient)
{
for (int i = 0; i < 1; i++)
{
NetworkingManager.RPC_Others(typeof(LarrysMod), "UpdateValues", new object[4] { enableWinnerDrawLess, winnerDrawAmount, StartingPicks, StartingDraws });
}
}
}
private static void UpdateValues(bool WinnerDraw, int WinnerDrawValue, int Picks, int Draws)
{
StartingPicks = Picks;
StartingDraws = Draws;
enableWinnerDrawLess = WinnerDraw;
winnerDrawAmount = WinnerDrawValue;
}
private void BreadGUI(GameObject menu)
{
if ((Object)(object)menu == (Object)null)
{
Debug.LogError("Menu object is null.");
return;
}
TextMeshProUGUI val = default(TextMeshProUGUI);
MenuHandler.CreateText("Drawing Cards", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
MenuHandler.CreateToggle(EnableWinnerDrawLessConfig.Value, "Toggle Winner Draws", menu, (UnityAction<bool>)delegate(bool value)
{
EnableWinnerDrawLessConfig.Value = value;
enableWinnerDrawLess = value;
}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
Slider val2 = default(Slider);
MenuHandler.CreateSlider("Winner Draws", menu, 20, 1f, 20f, (float)winnerDrawAmount, (UnityAction<float>)delegate(float value)
{
WinnerDrawAmountConfig.Value = (int)value;
winnerDrawAmount = (int)value;
}, ref val2, true, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
Slider val3 = default(Slider);
MenuHandler.CreateSlider("Starting Picks", menu, 20, 1f, 20f, (float)StartingPicks, (UnityAction<float>)delegate(float value)
{
StartingPicksConfig.Value = (int)value;
StartingPicks = (int)value;
}, ref val3, true, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
Slider val4 = default(Slider);
MenuHandler.CreateSlider("Extra Starting Draws", menu, 20, -5f, 20f, (float)StartingDraws, (UnityAction<float>)delegate(float value)
{
StartingDrawsConfig.Value = (int)value;
StartingDraws = (int)value;
}, ref val4, true, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
}
[IteratorStateMachine(typeof(<RoundEnd>d__25))]
private IEnumerator RoundEnd(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RoundEnd>d__25(0)
{
<>4__this = this,
gm = gm
};
}
public void fixWinnerDrawThing(Player player)
{
if (EnableWinnerDrawLessConfig.Value && !PlayersItsDonefor.Contains(player))
{
List<int> roundWinners = GetRoundWinners();
if (roundWinners != null && roundWinners.Contains(player.teamID) && WinnerDraws[player.playerID] != DrawNCards.GetPickerDraws(player.playerID))
{
PlayersItsDonefor[player.playerID] = player;
DrawNCards.RPCA_SetPickerDraws(player.playerID, WinnerDraws[player.playerID]);
}
}
}
[IteratorStateMachine(typeof(<PickEnd>d__27))]
private IEnumerator PickEnd(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PickEnd>d__27(0)
{
<>4__this = this,
gm = gm
};
}
[IteratorStateMachine(typeof(<PickStart>d__28))]
private IEnumerator PickStart(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PickStart>d__28(0)
{
<>4__this = this,
gm = gm
};
}
[IteratorStateMachine(typeof(<GameEnd>d__29))]
private IEnumerator GameEnd(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GameEnd>d__29(0)
{
<>4__this = this,
gm = gm
};
}
[IteratorStateMachine(typeof(<FirstRoundStart>d__30))]
private IEnumerator FirstRoundStart(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <FirstRoundStart>d__30(0)
{
<>4__this = this,
gm = gm
};
}
[IteratorStateMachine(typeof(<GameStart>d__31))]
private IEnumerator GameStart(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GameStart>d__31(0)
{
<>4__this = this,
gm = gm
};
}
public int PlayerDrawsIncrease(Player player, int Amount)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
if (GameModeManager.CurrentHandler.GetTeamScore(player.teamID).rounds > 0)
{
instance.fixWinnerDrawThing(player);
}
DrawNCards.RPCA_SetPickerDraws(player.playerID, DrawNCards.GetPickerDraws(player.playerID) + Amount);
return DrawNCards.GetPickerDraws(player.playerID);
}
}
}
