using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CoinFlip.Handlers;
using CoinFlip.Validators;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Photon.Pun;
using REPOLib.Commands;
using REPOLib.Modules;
using UnityEngine;
using UnityEngine.Events;
[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("NotDrunkJustHigh")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a1b778bfdca6aa3daa7ebb9c1d7b99ea96fb668c")]
[assembly: AssemblyProduct("Coinflip")]
[assembly: AssemblyTitle("Coinflip")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 CoinFlip
{
[BepInPlugin("NotDrunkJustHigh.Coinflip", "Coinflip", "2.0.0")]
public class Coinflip : BaseUnityPlugin
{
public static NetworkedEvent HandleCoinFlipResultEvent;
private static NetworkedEvent SyncConfigEvent;
public static NetworkedEvent UpgradeFlipEvent;
private float _configSyncTimer = 0f;
private const float CONFIG_SYNC_INTERVAL = 10f;
internal static Coinflip Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
public static bool ShopOnly { get; set; }
public static int MaxBetAmount { get; set; }
public static int MinBetAmount { get; set; }
public static bool TaxEnabled { get; set; }
public static float TaxAmount { get; set; }
public static bool SuperFlipEnabled { get; set; }
public static int SuperFlipMax { get; set; }
public static float SuperFlipMultiplier { get; set; }
private void Awake()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
Instance = this;
SetupConfig();
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
HandleCoinFlipResultEvent = new NetworkedEvent("Handle CoinFlip Result", (Action<EventData>)RPC_AddOrRemoveMoney);
SyncConfigEvent = new NetworkedEvent("SyncConfig", (Action<EventData>)RPC_SyncConfig);
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
if (PhotonNetwork.IsMasterClient && SemiFunc.RunIsShop())
{
_configSyncTimer += Time.deltaTime;
if (_configSyncTimer >= 10f)
{
_configSyncTimer = 0f;
RPC_ConfigSyncData rPC_ConfigSyncData = new RPC_ConfigSyncData
{
ShopOnly = ShopOnly,
MaxBetAmount = MaxBetAmount,
MinBetAmount = MinBetAmount,
TaxEnabled = TaxEnabled,
TaxAmount = TaxAmount,
SuperFlipEnabled = SuperFlipEnabled,
SuperFlipMax = SuperFlipMax,
SuperFlipMultiplier = SuperFlipMultiplier
};
string text = JsonConvert.SerializeObject((object)rPC_ConfigSyncData);
SyncConfigEvent.RaiseEvent((object)text, NetworkingEvents.RaiseOthers, SendOptions.SendUnreliable);
Logger.LogDebug((object)"[CoinFlip] Sent config sync to all clients");
}
}
}
public void SetupConfig()
{
ConfigEntry<bool> shopOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Shop Only", true, "Whether you can flip coins only within the shop");
shopOnly.SettingChanged += delegate
{
ShopOnly = shopOnly.Value;
};
ShopOnly = shopOnly.Value;
ConfigEntry<int> maxBetAmount = ((BaseUnityPlugin)this).Config.Bind<int>("Bet Limitations", "Max Bet Amount", 1000, "The maximum amount of money that can be bet. 1 is equal 1,000(100 would set a max of 100,000) ");
ConfigEntry<int> minBetAmount = ((BaseUnityPlugin)this).Config.Bind<int>("Bet Limitations", "Min Bet Amount", 1, "The minimum amount of money that can be bet. 1 is equal 1,000");
maxBetAmount.SettingChanged += delegate
{
MaxBetAmount = maxBetAmount.Value;
};
minBetAmount.SettingChanged += delegate
{
MinBetAmount = minBetAmount.Value;
};
MaxBetAmount = maxBetAmount.Value;
MinBetAmount = minBetAmount.Value;
ConfigEntry<bool> taxEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Taxes", "Tax Enabled", false, "Whether or not tax is enabled");
ConfigEntry<float> taxAmount = ((BaseUnityPlugin)this).Config.Bind<float>("Taxes", "Tax Amount", 0.1f, "The amount of money that is taxed on every win");
taxEnabled.SettingChanged += delegate
{
TaxEnabled = taxEnabled.Value;
};
taxAmount.SettingChanged += delegate
{
TaxAmount = taxAmount.Value;
};
TaxEnabled = taxEnabled.Value;
TaxAmount = taxAmount.Value;
ConfigEntry<bool> superFlipEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Super Flips", "Super Flips Enabled", true, "Whether or not super flips are enabled");
ConfigEntry<int> superFlipMax = ((BaseUnityPlugin)this).Config.Bind<int>("Super Flips", "Super Flips Max", 5, "The maximum amount of super flips that can be played");
ConfigEntry<float> superFlipMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Super Flips", "Super Flips Multiplier", 2.75f, "The multiplier per flip that is applied to the amount of money won on a super flip");
superFlipEnabled.SettingChanged += delegate
{
SuperFlipEnabled = superFlipEnabled.Value;
};
superFlipMax.SettingChanged += delegate
{
SuperFlipMax = superFlipMax.Value;
};
superFlipMultiplier.SettingChanged += delegate
{
SuperFlipMultiplier = superFlipMultiplier.Value;
};
SuperFlipEnabled = superFlipEnabled.Value;
SuperFlipMax = superFlipMax.Value;
SuperFlipMultiplier = superFlipMultiplier.Value;
}
public void RPC_AddOrRemoveMoney(EventData eventData)
{
Logger.LogDebug((object)"[CoinFlip] Received RPC to add or remove money.");
int sender = eventData.Sender;
if (!PhotonNetwork.IsMasterClient)
{
Logger.LogDebug((object)"[CoinFlip] Received RPC but we are not the host. Ignoring.");
return;
}
int num = SemiFunc.StatGetRunCurrency();
string[] array = ((string)eventData.CustomData).Split(' ');
int num2 = int.Parse(array[0]);
string text = array[1];
int num3 = num + ((text == "won") ? num2 : (-num2));
Logger.LogDebug((object)$"[CoinFlip] Received request to modify currency by {num2} from {sender} with action {text}.");
SemiFunc.StatSetRunCurrency(num3);
int num4 = SemiFunc.StatGetRunCurrency();
if (num3 != num4)
{
Logger.LogError((object)$"[CoinFlip] Currency was not updated correctly. Expected: {num3} | Actual: {num4}");
}
}
public void RPC_SyncConfig(EventData eventData)
{
Logger.LogDebug((object)"[CoinFlip] Received RPC to sync config.");
if (PhotonNetwork.IsMasterClient)
{
Logger.LogDebug((object)"[CoinFlip] Received RPC to sync config, but current client is host. Ignoring.");
return;
}
Logger.LogDebug((object)"[CoinFlip] Received RPC to sync config. Attempting to sync config...");
if (!(eventData.CustomData is string text))
{
Logger.LogError((object)"[CoinFlip] Received Config was null");
return;
}
RPC_ConfigSyncData rPC_ConfigSyncData = JsonConvert.DeserializeObject<RPC_ConfigSyncData>(text);
if (rPC_ConfigSyncData != null)
{
ShopOnly = rPC_ConfigSyncData.ShopOnly;
MaxBetAmount = rPC_ConfigSyncData.MaxBetAmount;
MinBetAmount = rPC_ConfigSyncData.MinBetAmount;
TaxEnabled = rPC_ConfigSyncData.TaxEnabled;
TaxAmount = rPC_ConfigSyncData.TaxAmount;
SuperFlipEnabled = rPC_ConfigSyncData.SuperFlipEnabled;
SuperFlipMax = rPC_ConfigSyncData.SuperFlipMax;
SuperFlipMultiplier = rPC_ConfigSyncData.SuperFlipMultiplier;
Logger.LogDebug((object)"[CoinFlip] Received and set Config successfully");
}
else
{
Logger.LogError((object)"[CoinFlip] Received Config could not be serialized");
}
}
}
public class RPC_ConfigSyncData
{
public bool ShopOnly { get; set; }
public int MaxBetAmount { get; set; }
public int MinBetAmount { get; set; }
public bool TaxEnabled { get; set; }
public float TaxAmount { get; set; }
public bool SuperFlipEnabled { get; set; }
public int SuperFlipMax { get; set; }
public float SuperFlipMultiplier { get; set; }
}
}
namespace CoinFlip.Validators
{
public static class LocationValidator
{
public static bool CanGambleInCurrentLocation()
{
if (Coinflip.ShopOnly && !SemiFunc.RunIsShop())
{
Coinflip.Logger.LogInfo((object)"[CoinFlip] Player is not in the shop and shop only gaming is enabled. Not continuing.");
return false;
}
Coinflip.Logger.LogInfo((object)"[CoinFlip] Player is in the shop. Continuing...");
return true;
}
}
}
namespace CoinFlip.Handlers
{
public static class CoinFlipMessenger
{
public static void SendIncorrectLocationMessage()
{
SendMessageWithRedEyes("I can only gamble in the shop!", sendInTaxManChat: false);
}
public static void SendWonMessage(int amount)
{
string message = FormatMessage(amount, won: true);
SendMessageWithGreenEyes(message, sendInTaxManChat: true);
}
public static void SendLostMessage(int amount)
{
string message = FormatMessage(amount, won: false);
SendMessageWithRedEyes(message, sendInTaxManChat: true);
}
private static string FormatMessage(int amount, bool won)
{
string arg = (won ? "won" : "lost");
if (amount >= 1000)
{
return $"I {arg} {amount} million from coin flipping";
}
return $"I {arg} {amount} thousand from coin flipping";
}
public static void SendMessageWithGreenEyes(string message, bool sendInTaxManChat)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
SendChatMessage(message, (PossessChatID)5, sendInTaxManChat, Color.green);
}
public static void SendMessageWithRedEyes(string message, bool sendInTaxManChat)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
SendChatMessage(message, (PossessChatID)3, sendInTaxManChat, Color.red);
}
public static void SendChatMessage(string message = "I forgot what I was going to say", PossessChatID possessChat = 3, bool sendInTaxmanChat = false, Color color = default(Color))
{
//IL_0022: 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)
Coinflip.Logger.LogDebug((object)"[CoinFlip] Sending public chat message");
ChatManager.instance.PossessChatScheduleStart(-1);
ChatManager.instance.PossessChat(possessChat, message, 4f, color, 0f, sendInTaxmanChat, 0, (UnityEvent)null);
ChatManager.instance.PossessChatScheduleEnd();
}
}
public class CoinFlipper
{
public static bool FlipCoin()
{
return GenerateRandomBoolean();
}
public static (bool success, string message) SuperFlip(string totalSuperFlipsString, double initialMultiplier, out bool won, out double finalMultiplier)
{
if (!Coinflip.SuperFlipEnabled)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super Flips are not enabled");
won = false;
finalMultiplier = 0.0;
return (false, "Super Flips are not enabled");
}
int? superFlipAmount;
(bool, string) result = BetValidator.TryParseSuperFlipAndValidateAmount(totalSuperFlipsString, out superFlipAmount);
if (!result.Item1)
{
Coinflip.Logger.LogDebug((object)("[CoinFlip] Super Flips amount was not valid. " + totalSuperFlipsString));
won = false;
finalMultiplier = 0.0;
return result;
}
double num = initialMultiplier;
double num2 = 1.0;
for (int i = 2; i < superFlipAmount; i++)
{
if (!FlipCoin())
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] User lost the CF.");
won = false;
finalMultiplier = 1.0;
return (true, string.Empty);
}
num2 /= 2.0;
num += initialMultiplier - initialMultiplier * (1.0 - num2);
}
Coinflip.Logger.LogDebug((object)"[CoinFlip] Coin was heads but player chose to flip tails.");
won = true;
finalMultiplier = num;
return (true, string.Empty);
}
private static bool GenerateRandomBoolean()
{
return (int)GenerateRandomPercentage(2) == 0;
}
private static float GenerateRandomPercentage(int maxNumber = 100)
{
using RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
byte[] array = new byte[1];
randomNumberGenerator.GetBytes(array);
return array[0] % maxNumber;
}
}
public static class CurrencyManager
{
public static int ProcessGambleResult(bool userWon, int amount, double superFlipMultiplier = 1.0)
{
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
int num = SemiFunc.StatGetRunCurrency();
amount = (int)((double)amount * superFlipMultiplier);
if (Coinflip.TaxEnabled && userWon)
{
float taxAmount = Coinflip.TaxAmount;
Coinflip.Logger.LogDebug((object)$"[CoinFlip] Tax enabled with a tax percent of {taxAmount}");
int num2 = (int)((float)amount * taxAmount);
amount -= num2;
Coinflip.Logger.LogDebug((object)$"[CoinFlip] Total Tax: {num2} | new amount: {amount}");
}
if (SemiFunc.IsMultiplayer())
{
if (PhotonNetwork.IsMasterClient)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] User is host. modifying directly");
SemiFunc.StatSetRunCurrency(num + (userWon ? amount : (-amount)));
return amount;
}
Coinflip.Logger.LogInfo((object)"[CoinFlip] Sending handle CoinFlip result event to master client");
string arg = (userWon ? "won" : "lost");
string text = $"{amount} {arg}";
Coinflip.HandleCoinFlipResultEvent.RaiseEvent((object)text, NetworkingEvents.RaiseMasterClient, SendOptions.SendReliable);
return amount;
}
Coinflip.Logger.LogInfo((object)"[CoinFlip] Single player detected. Updating currency directly.");
SemiFunc.StatSetRunCurrency(num + (userWon ? amount : (-amount)));
return amount;
}
public static void ProcessUpgradeFlipResult(bool userWon, string type, int amount)
{
throw new NotImplementedException();
}
}
public static class BetValidator
{
private static bool AmountIsValid(int amount)
{
return amount <= Coinflip.MaxBetAmount && amount >= Coinflip.MinBetAmount;
}
private static bool UsersHaveEnoughMoney(int required)
{
return required <= SemiFunc.StatGetRunCurrency();
}
public static (bool success, string message) TryParseBetAmount(string betAmount, out int amount)
{
amount = 0;
if (betAmount.EndsWith('k'))
{
string text = betAmount;
string s = text.Substring(0, text.Length - 1);
if (int.TryParse(s, out var result))
{
amount = result;
}
}
else if (betAmount.EndsWith('m'))
{
string text = betAmount;
string s2 = text.Substring(0, text.Length - 1);
if (int.TryParse(s2, out var result2))
{
amount = result2 * 1000;
}
}
else
{
if (betAmount.Length < 4)
{
return (false, "I have to specify a valid amount. Like 1k or 1000");
}
if (int.TryParse(betAmount, out var result3))
{
amount = result3 / 1000;
}
}
if (!UsersHaveEnoughMoney(amount))
{
Coinflip.Logger.LogDebug((object)$"[CoinFlip] Amount: {amount} ActualAmount: {SemiFunc.StatGetRunCurrency()} | UsersHaveEnoughMoney: {UsersHaveEnoughMoney(amount)}");
return (false, "We don't have enough money to make that bet.");
}
if (!AmountIsValid(amount))
{
return (false, $"My bet must be between {Coinflip.MinBetAmount} and {Coinflip.MaxBetAmount}");
}
return (true, string.Empty);
}
public static (bool success, string message) TryParseCoinSide(string side, out bool isHeads)
{
string text = side.ToLower();
if ((text == "heads" || text == "h") ? true : false)
{
isHeads = true;
return (true, string.Empty);
}
text = side.ToLower();
if ((text == "tails" || text == "t") ? true : false)
{
isHeads = false;
return (true, string.Empty);
}
isHeads = false;
return (false, "Invalid coin side. Must be heads or tails");
}
public static (bool success, string message) TryParseSuperFlipAndValidateAmount(string superFlipAmountString, out int? superFlipAmount)
{
bool superFlipEnabled = Coinflip.SuperFlipEnabled;
int superFlipMax = Coinflip.SuperFlipMax;
Coinflip.Logger.LogDebug((object)$"[CoinFlip] SuperFlipEnabled: {superFlipEnabled} | SuperFlipMax: {superFlipMax}");
if (!superFlipEnabled)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super Flips are not enabled. Stopping execution");
superFlipAmount = null;
return (false, "Super Flips are not enabled");
}
if (!int.TryParse(superFlipAmountString, out var result))
{
superFlipAmount = null;
return (false, "Super Flip Amount must be a number");
}
if (result < 2)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super Flips amount was less than 2. This is not allowed.");
superFlipAmount = null;
return (false, "I need to super flip at least 2 times");
}
if (result > superFlipMax)
{
Coinflip.Logger.LogDebug((object)$"[CoinFlip] Super Flip Amount: {result} | SuperFlipMax: {superFlipMax}");
superFlipAmount = null;
return (false, $"My super flip can't be more than {superFlipMax}");
}
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super Flip validation passed");
superFlipAmount = result;
return (true, "Success");
}
public static bool TryParseUpgradeType(string amountString, string upgradeType, out int amount)
{
throw new NotImplementedException();
}
}
}
namespace CoinFlip.Commands
{
public static class CoinFlipCommand
{
[CommandExecution("coinflip", "Gamble your money by flipping a coin. Try /cf 1k h", true, false)]
[CommandAlias("cf")]
[CommandAlias("coinflip")]
public static async Task Execute(string args)
{
PlayerAvatar avatar = PlayerAvatar.instance;
bool isMasterClient = PhotonNetwork.IsMasterClient;
bool isMultiplayer = SemiFunc.IsMultiplayer();
Coinflip.Logger.LogDebug((object)$"[CoinFlip] IsMasterClient: {isMasterClient} | IsMultiplayer: {isMultiplayer} | PlayerName: {avatar.playerName}");
if (!LocationValidator.CanGambleInCurrentLocation())
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Player is not in the shop.");
CoinFlipMessenger.SendIncorrectLocationMessage();
return;
}
string[] coinFlipArgs = args.Split(' ');
Coinflip.Logger.LogDebug((object)$"[CoinFlip] Args are {args} arg length {coinFlipArgs.Length}");
string amountBetString = coinFlipArgs[0];
int amount;
(bool success, string message) betValidatorResult = BetValidator.TryParseBetAmount(amountBetString, out amount);
if (!betValidatorResult.success)
{
Coinflip.Logger.LogDebug((object)("[CoinFlip] Amount was not valid. " + amountBetString));
await Task.Delay(3200);
CoinFlipMessenger.SendMessageWithRedEyes(betValidatorResult.message, sendInTaxManChat: false);
return;
}
string betChoiceString = coinFlipArgs[1];
bool isHeads;
(bool success, string message) coinSideResult = BetValidator.TryParseCoinSide(betChoiceString, out isHeads);
if (!coinSideResult.success)
{
Coinflip.Logger.LogDebug((object)("[CoinFlip] Coin side was not valid. " + betChoiceString));
await Task.Delay(3200);
CoinFlipMessenger.SendMessageWithRedEyes(coinSideResult.message, sendInTaxManChat: false);
return;
}
if (coinFlipArgs.Length == 2)
{
bool headsWon = CoinFlipper.FlipCoin();
if (!headsWon && isHeads)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Coin was heads but player chose to flip tails.");
int amountLost2 = CurrencyManager.ProcessGambleResult(userWon: false, amount);
await Task.Delay(3200);
CoinFlipMessenger.SendLostMessage(amountLost2);
}
else
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Coin was tails but player chose to flip heads.");
int amountWon2 = CurrencyManager.ProcessGambleResult(userWon: true, amount);
await Task.Delay(3200);
CoinFlipMessenger.SendWonMessage(amountWon2);
}
return;
}
string totalSuperFlipsString = coinFlipArgs[2];
bool won;
double multiplier;
(bool success, string message) superFlipResult = CoinFlipper.SuperFlip(totalSuperFlipsString, Coinflip.SuperFlipMultiplier, out won, out multiplier);
if (!superFlipResult.success)
{
Coinflip.Logger.LogDebug((object)("[CoinFlip] Super flip was not valid. " + totalSuperFlipsString));
CoinFlipMessenger.SendMessageWithRedEyes(superFlipResult.message, sendInTaxManChat: false);
}
else if (!won)
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super flip was not won.");
int amountLost2 = CurrencyManager.ProcessGambleResult(userWon: false, amount, multiplier);
await Task.Delay(3200);
CoinFlipMessenger.SendLostMessage(amountLost2);
}
else
{
Coinflip.Logger.LogDebug((object)"[CoinFlip] Super flip was won.");
int amountWon2 = CurrencyManager.ProcessGambleResult(userWon: true, amount, multiplier);
await Task.Delay(3200);
CoinFlipMessenger.SendWonMessage(amountWon2);
}
}
}
}
