using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using FMOD.Studio;
using FMODUnity;
using Mirror;
using MoreMountains.Feedbacks;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace GWYFCustom
{
public abstract class GameCoreBase : GameBase
{
protected Random serverRng = new Random(Environment.TickCount * 31 + 17);
private Coroutine resetRoutine;
private Coroutine finishRoutine;
public GameObject rulesPanel;
private bool infoShown;
public override bool Weaved()
{
return true;
}
protected override void OnAwake()
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
((GameBase)this).OnAwake();
base.gameType = (CasinoGameType)12;
if (string.IsNullOrEmpty(base.gameName))
{
base.gameName = ((object)this).GetType().Name;
}
MMFloatingTextSpawner componentInChildren = ((Component)this).GetComponentInChildren<MMFloatingTextSpawner>(true);
if ((Object)(object)componentInChildren != (Object)null)
{
Object.DestroyImmediate((Object)(object)componentInChildren);
}
}
protected void BroadcastString(string rpcMethodName, string payload)
{
if (NetworkServer.active)
{
string text = "System.Void " + ((object)this).GetType().FullName + "::" + rpcMethodName + "(System.String)";
int stableHashCode = Extensions.GetStableHashCode(text);
NetworkWriterPooled val = NetworkWriterPool.Get();
NetworkWriterExtensions.WriteString((NetworkWriter)(object)val, payload);
((NetworkBehaviour)this).SendRPCInternal(text, stableHashCode, (NetworkWriter)(object)val, 0, true);
NetworkWriterPool.Return(val);
}
}
protected void FinishRound(float multiplier, float delay)
{
if (((NetworkBehaviour)this).isServer)
{
if (finishRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(finishRoutine);
}
finishRoutine = ((MonoBehaviour)this).StartCoroutine(FinishRoundRoutine(multiplier, delay));
}
}
private IEnumerator FinishRoundRoutine(float multiplier, float delay)
{
yield return (object)new WaitForSeconds(delay);
finishRoutine = null;
base.isPlaying = false;
((GameBase)this).Payout((double)multiplier, (ChangeType)1, (Dictionary<string, object>)null, (BigNumber?)null);
resetRoutine = ((MonoBehaviour)this).StartCoroutine(ResetRoundRoutine());
}
private IEnumerator ResetRoundRoutine()
{
yield return (object)new WaitForSeconds(2f);
BroadcastString("UserRpcResetVisuals", "reset");
resetRoutine = null;
((GameBase)this).ResetGame();
}
protected void GuardStuckReset()
{
if (resetRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(resetRoutine);
resetRoutine = null;
BroadcastString("UserRpcResetVisuals", "reset");
((GameBase)this).ResetGame();
}
}
public void UserRpcResetVisuals(string networkText)
{
if (NetworkClient.active)
{
OnClientResetVisuals();
}
}
protected abstract void OnClientResetVisuals();
[Server]
public void ToggleInfo(PlayerInteract interact = null)
{
if (NetworkServer.active)
{
infoShown = !infoShown;
BroadcastString("UserRpcToggleInfo", infoShown ? "1" : "0");
}
}
public void UserRpcToggleInfo(string networkText)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (NetworkClient.active)
{
if ((Object)(object)rulesPanel != (Object)null)
{
rulesPanel.SetActive(networkText == "1");
}
Sfx.Play(((Component)this).transform.position, "KeypadButton", "Button");
}
}
protected int WeightedIndex(int[] weights)
{
return PureRng.WeightedIndex(serverRng, weights);
}
protected static string F(float v)
{
return v.ToString("0.###", CultureInfo.InvariantCulture);
}
protected static float PF(string s)
{
float.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
return result;
}
protected static int PI(string s)
{
int.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
return result;
}
}
public static class PureRng
{
public static int WeightedIndex(Random rng, int[] weights)
{
int num = 0;
for (int i = 0; i < weights.Length; i++)
{
num += weights[i];
}
int num2 = rng.Next(num);
for (int j = 0; j < weights.Length; j++)
{
num2 -= weights[j];
if (num2 < 0)
{
return j;
}
}
return weights.Length - 1;
}
}
public static class ScratchLogic
{
public static float Generate(Random rng, float[] tierMult, double[] tierProb, int[] tierSym, int symbolCount, int[] cells)
{
int num = cells.Length;
double num2 = rng.NextDouble();
double num3 = 0.0;
int num4 = 0;
for (int i = 0; i < tierProb.Length; i++)
{
num3 += tierProb[i];
if (num2 < num3)
{
num4 = i;
break;
}
num4 = i;
}
float result = tierMult[num4];
int num5 = tierSym[num4];
for (int j = 0; j < 200; j++)
{
int[] array = new int[symbolCount];
bool flag = true;
if (num5 >= 0)
{
for (int k = 0; k < num; k++)
{
cells[k] = -1;
}
int num6 = 0;
while (num6 < 3)
{
int num7 = rng.Next(num);
if (cells[num7] == -1)
{
cells[num7] = num5;
num6++;
}
}
array[num5] = 3;
for (int l = 0; l < num; l++)
{
if (cells[l] == -1)
{
int num8 = PickFiller(rng, array, num5, symbolCount);
if (num8 < 0)
{
flag = false;
break;
}
cells[l] = num8;
array[num8]++;
}
}
}
else
{
for (int m = 0; m < num; m++)
{
int num9 = PickFiller(rng, array, -1, symbolCount);
if (num9 < 0)
{
flag = false;
break;
}
cells[m] = num9;
array[num9]++;
}
}
if (flag)
{
return result;
}
}
for (int n = 0; n < num; n++)
{
cells[n] = n % 2;
}
return 0f;
}
private static int PickFiller(Random rng, int[] counts, int excluded, int symbolCount)
{
for (int i = 0; i < 50; i++)
{
int num = rng.Next(symbolCount);
if (num != excluded && counts[num] < 2)
{
return num;
}
}
for (int j = 0; j < symbolCount; j++)
{
if (j != excluded && counts[j] < 2)
{
return j;
}
}
return -1;
}
}
public static class Sfx
{
private static List<KeyValuePair<string, EventDescription>> all;
private static readonly Dictionary<string, EventDescription?> cache = new Dictionary<string, EventDescription?>();
private static void EnsureLoaded()
{
//IL_0012: 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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: 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_0035: 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_0052: 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_006f: Unknown result type (might be due to invalid IL or missing references)
if (all != null)
{
return;
}
all = new List<KeyValuePair<string, EventDescription>>();
try
{
System studioSystem = RuntimeManager.StudioSystem;
Bank[] array = default(Bank[]);
((System)(ref studioSystem)).getBankList(ref array);
Bank[] array2 = array;
EventDescription[] array3 = default(EventDescription[]);
string text = default(string);
for (int i = 0; i < array2.Length; i++)
{
Bank val = array2[i];
if ((int)((Bank)(ref val)).getEventList(ref array3) != 0 || array3 == null)
{
continue;
}
EventDescription[] array4 = array3;
for (int j = 0; j < array4.Length; j++)
{
EventDescription value = array4[j];
if ((int)((EventDescription)(ref value)).getPath(ref text) == 0 && !string.IsNullOrEmpty(text))
{
all.Add(new KeyValuePair<string, EventDescription>(text, value));
}
}
}
Debug.Log((object)("[GWYFCustom] FMOD events discovered: " + all.Count));
foreach (KeyValuePair<string, EventDescription> item in all)
{
string text2 = item.Key.ToLowerInvariant();
if (text2.Contains("slot") || text2.Contains("casino") || text2.Contains("win") || text2.Contains("button") || text2.Contains("lever") || text2.Contains("cash") || text2.Contains("keypad") || text2.Contains("spin"))
{
Debug.Log((object)("[GWYFCustom] FMOD event: " + item.Key));
}
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[GWYFCustom] FMOD enumeration failed: " + ex.Message));
}
}
private static EventDescription? Find(string[] candidates)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
EnsureLoaded();
string text = string.Join("|", candidates);
if (cache.TryGetValue(text, out var value))
{
return value;
}
foreach (string text2 in candidates)
{
string value2 = text2.ToLowerInvariant();
foreach (KeyValuePair<string, EventDescription> item in all)
{
if (item.Key.ToLowerInvariant().Contains(value2))
{
cache[text] = item.Value;
Debug.Log((object)("[GWYFCustom] SFX '" + text2 + "' -> " + item.Key));
return item.Value;
}
}
}
Debug.LogWarning((object)("[GWYFCustom] no FMOD event matches: " + text));
cache[text] = null;
return null;
}
public static void Play(Vector3 position, params string[] candidates)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
PlayParam(position, null, 0f, candidates);
}
public static void PlayParam(Vector3 position, string paramName, float value, params string[] candidates)
{
//IL_0014: 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)
//IL_001e: 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_002a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: 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)
try
{
EventDescription? val = Find(candidates);
if (!val.HasValue)
{
return;
}
EventDescription value2 = val.Value;
EventInstance val2 = default(EventInstance);
if ((int)((EventDescription)(ref value2)).createInstance(ref val2) == 0)
{
((EventInstance)(ref val2)).set3DAttributes(RuntimeUtils.To3DAttributes(position));
if (!string.IsNullOrEmpty(paramName))
{
((EventInstance)(ref val2)).setParameterByName(paramName, value, false);
}
((EventInstance)(ref val2)).start();
((EventInstance)(ref val2)).release();
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[GWYFCustom] SFX play failed: " + ex.Message));
}
}
}
}
namespace GWYFCustom.Games
{
public static class DeepSeaSlotsLogic
{
public static float Evaluate(int[] grid, out int cellMask)
{
int num = grid[0];
int num2 = grid[1];
int num3 = grid[2];
cellMask = 0;
if (num == num2 && num2 == num3)
{
cellMask = 7;
return DeepSeaPay.PAY3[num];
}
int num4 = 0;
for (int i = 0; i < 3; i++)
{
if (grid[i] == 5)
{
num4++;
cellMask |= 1 << i;
}
}
switch (num4)
{
case 1:
return 1.5f;
case 2:
return 6f;
default:
cellMask = 0;
return 0f;
}
}
public static float SpinOnce(Random rng)
{
int[] array = new int[3];
for (int i = 0; i < 3; i++)
{
array[i] = PureRng.WeightedIndex(rng, DeepSeaPay.WEIGHTS);
}
int cellMask;
return Evaluate(array, out cellMask);
}
}
public static class DeucesWildLogic
{
public const int NONE = 0;
public const int THREE_KIND = 1;
public const int STRAIGHT = 2;
public const int FLUSH = 3;
public const int FULL_HOUSE = 4;
public const int FOUR_KIND = 5;
public const int STRAIGHT_FLUSH = 6;
public const int FIVE_KIND = 7;
public const int WILD_ROYAL = 8;
public const int FOUR_DEUCES = 9;
public const int NATURAL_ROYAL = 10;
private static int Rank(int card)
{
return card % 13;
}
private static int Suit(int card)
{
return card / 13;
}
private static bool IsWild(int card)
{
return card % 13 == 0;
}
public static int Evaluate(int[] hand, out int winMask)
{
winMask = 31;
int num = 0;
int[] array = new int[5];
int num2 = 0;
for (int i = 0; i < 5; i++)
{
if (IsWild(hand[i]))
{
num++;
}
else
{
array[num2++] = hand[i];
}
}
if (num == 4)
{
return 9;
}
int[] array2 = new int[13];
int num3 = 0;
int num4 = 0;
bool flag = true;
bool flag2 = true;
for (int j = 0; j < num2; j++)
{
int num5 = Rank(array[j]);
array2[num5]++;
if (array2[num5] == 1)
{
num4++;
}
if (array2[num5] > num3)
{
num3 = array2[num5];
}
if (Suit(array[j]) != Suit(array[0]))
{
flag = false;
}
if (num5 < 8)
{
flag2 = false;
}
}
bool flag3 = num3 <= 1;
if (num == 0 && flag && flag3 && flag2)
{
return 10;
}
if (num > 0 && flag && flag3 && flag2)
{
return 8;
}
if (num3 + num >= 5)
{
return 7;
}
if (flag && flag3 && StraightPossible(array, num2, num))
{
return 6;
}
if (num3 + num >= 4)
{
return 5;
}
if (num4 == 2)
{
return 4;
}
if (flag)
{
return 3;
}
if (flag3 && StraightPossible(array, num2, num))
{
return 2;
}
if (num3 + num >= 3)
{
return 1;
}
winMask = 0;
return 0;
}
private static bool StraightPossible(int[] others, int n, int d)
{
for (int i = 0; i <= 8; i++)
{
if (AllInWindow(others, n, i, i + 4, aceLow: false))
{
return true;
}
}
if (AllInWindow(others, n, 0, 3, aceLow: true))
{
return true;
}
return false;
}
private static bool AllInWindow(int[] others, int n, int lo, int hi, bool aceLow)
{
for (int i = 0; i < n; i++)
{
int num = others[i] % 13;
if ((!aceLow || num != 12) && (num < lo || num > hi))
{
return false;
}
}
return true;
}
public static int HoldMask(int[] hand)
{
int num = 0;
int num2 = 0;
for (int i = 0; i < 5; i++)
{
if (IsWild(hand[i]))
{
num |= 1 << i;
num2++;
}
}
int winMask;
int num3 = Evaluate(hand, out winMask);
switch (num2)
{
case 4:
return 31;
case 3:
if (num3 == 8 || num3 == 7)
{
return 31;
}
return num;
case 2:
{
if (num3 >= 6)
{
return 31;
}
if (num3 == 5)
{
return num | MadeRankMask(hand);
}
int num12 = SuitedRoyalWith(hand, num, 2);
if (num12 != 0)
{
return num12;
}
return num;
}
case 1:
switch (num3)
{
case 6:
case 7:
case 8:
return 31;
case 5:
return num | MadeRankMask(hand);
default:
{
int num11 = SuitedRoyalWith(hand, num, 3);
if (num11 != 0)
{
return num11;
}
if (num3 == 4 || num3 == 3 || num3 == 2)
{
return 31;
}
num11 = SuitedStraightDrawWith(hand, num, 3);
if (num11 != 0)
{
return num11;
}
if (num3 == 1)
{
return num | MadeRankMask(hand);
}
num11 = SuitedRoyalWith(hand, num, 2);
if (num11 != 0)
{
return num11;
}
return num;
}
}
default:
{
if (num3 == 10)
{
return 31;
}
int num4 = SuitedRoyalNatural(hand, 4);
if (num4 != 0)
{
return num4;
}
switch (num3)
{
case 6:
return 31;
case 5:
return MadeRankMask(hand);
case 2:
case 3:
case 4:
return 31;
case 1:
return MadeRankMask(hand);
default:
{
int num5 = SuitedRoyalNatural(hand, 3);
if (num5 != 0)
{
return num5;
}
int num6 = OnePairMask(hand);
if (num6 != 0)
{
return num6;
}
int num7 = SuitedStraightDrawNatural(hand, 4);
if (num7 != 0)
{
return num7;
}
int num8 = SuitedNatural(hand, 4);
if (num8 != 0)
{
return num8;
}
int num9 = OpenStraightDraw(hand);
if (num9 != 0)
{
return num9;
}
int num10 = SuitedRoyalNatural(hand, 2);
if (num10 != 0)
{
return num10;
}
return 0;
}
}
}
}
}
private static int MadeRankMask(int[] hand)
{
int[] array = new int[13];
for (int i = 0; i < 5; i++)
{
if (!IsWild(hand[i]))
{
array[Rank(hand[i])]++;
}
}
int num = -1;
for (int j = 1; j < 13; j++)
{
if (num < 0 || array[j] > array[num])
{
num = j;
}
}
int num2 = 0;
for (int k = 0; k < 5; k++)
{
if (!IsWild(hand[k]) && Rank(hand[k]) == num)
{
num2 |= 1 << k;
}
}
return num2;
}
private static int SuitedRoyalWith(int[] hand, int deuceMask, int need)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
int num3 = 0;
bool flag = false;
for (int j = 0; j < 5; j++)
{
if (!IsWild(hand[j]) && Suit(hand[j]) == i && Rank(hand[j]) >= 8)
{
if ((num3 & (1 << Rank(hand[j]))) != 0)
{
flag = true;
break;
}
num3 |= 1 << Rank(hand[j]);
num |= 1 << j;
num2++;
}
}
if (!flag && num2 >= need)
{
return deuceMask | num;
}
}
return 0;
}
private static int SuitedRoyalNatural(int[] hand, int need)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
int num3 = 0;
bool flag = false;
int num4 = 13;
for (int j = 0; j < 5; j++)
{
if (!IsWild(hand[j]) && Suit(hand[j]) == i && Rank(hand[j]) >= 8)
{
if ((num3 & (1 << Rank(hand[j]))) != 0)
{
flag = true;
break;
}
num3 |= 1 << Rank(hand[j]);
num |= 1 << j;
num2++;
if (Rank(hand[j]) < num4)
{
num4 = Rank(hand[j]);
}
}
}
if (!flag && num2 >= need && (need != 2 || num4 >= 9))
{
return num;
}
}
return 0;
}
private static int SuitedStraightDrawWith(int[] hand, int deuceMask, int need)
{
for (int i = 0; i < 4; i++)
{
int[] array = new int[5];
int num = 0;
for (int j = 0; j < 5; j++)
{
if (!IsWild(hand[j]) && Suit(hand[j]) == i)
{
array[num++] = j;
}
}
if (num < need)
{
continue;
}
for (int k = 0; k < 1 << num; k++)
{
int num2 = 0;
int num3 = 0;
int num4 = 0;
bool flag = false;
int[] array2 = new int[5];
int num5 = 0;
for (int l = 0; l < num; l++)
{
if ((k & (1 << l)) != 0)
{
int num6 = array[l];
int num7 = Rank(hand[num6]);
if ((num4 & (1 << num7)) != 0)
{
flag = true;
break;
}
num4 |= 1 << num7;
num3 |= 1 << num6;
array2[num5++] = hand[num6];
num2++;
}
}
if (!flag && num2 == need && StraightPossible(array2, num5, 5 - num5))
{
return deuceMask | num3;
}
}
}
return 0;
}
private static int SuitedStraightDrawNatural(int[] hand, int need)
{
return SuitedStraightDrawWith(hand, 0, need);
}
private static int SuitedNatural(int[] hand, int need)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
for (int j = 0; j < 5; j++)
{
if (!IsWild(hand[j]) && Suit(hand[j]) == i)
{
num |= 1 << j;
num2++;
}
}
if (num2 >= need)
{
return num;
}
}
return 0;
}
private static int OnePairMask(int[] hand)
{
int[] array = new int[13];
for (int i = 0; i < 5; i++)
{
if (!IsWild(hand[i]))
{
array[Rank(hand[i])]++;
}
}
for (int num = 12; num >= 1; num--)
{
if (array[num] == 2)
{
int num2 = 0;
for (int j = 0; j < 5; j++)
{
if (!IsWild(hand[j]) && Rank(hand[j]) == num)
{
num2 |= 1 << j;
}
}
return num2;
}
}
return 0;
}
private static int OpenStraightDraw(int[] hand)
{
for (int i = 0; i < 5; i++)
{
int num = 0;
int num2 = 0;
int num3 = 0;
bool flag = false;
bool flag2 = false;
int[] array = new int[5];
int n = 0;
for (int j = 0; j < 5; j++)
{
if (j != i)
{
if (IsWild(hand[j]))
{
flag2 = true;
break;
}
int num4 = Rank(hand[j]);
if ((num3 & (1 << num4)) != 0)
{
flag = true;
break;
}
num3 |= 1 << num4;
num |= 1 << j;
array[n++] = hand[j];
num2++;
}
}
if (!(flag2 || flag) && num2 == 4 && StraightPossible(array, n, 1))
{
return num;
}
}
return 0;
}
public static float SpinOnce(Random rng)
{
int[] array = new int[52];
VideoPokerLogic.Shuffle(rng, array);
int[] array2 = new int[5];
for (int i = 0; i < 5; i++)
{
array2[i] = array[i];
}
int num = HoldMask(array2);
int num2 = 5;
for (int j = 0; j < 5; j++)
{
if ((num & (1 << j)) == 0)
{
array2[j] = array[num2++];
}
}
int winMask;
int num3 = Evaluate(array2, out winMask);
return DeucesPay.PAYS[num3];
}
}
public static class JackpotSevensLogic
{
public static float Evaluate(int[] grid, out int cellMask)
{
int num = grid[0];
int num2 = grid[1];
int num3 = grid[2];
cellMask = 0;
if (num == num2 && num2 == num3 && SevensPay.TRIPLE[num] > 0f)
{
cellMask = 7;
return SevensPay.TRIPLE[num];
}
if ((num == 4 || num == 5) && (num2 == 4 || num2 == 5) && (num3 == 4 || num3 == 5))
{
cellMask = 7;
return 125f;
}
if ((num == 2 || num == 3) && (num2 == 2 || num2 == 3) && (num3 == 2 || num3 == 3))
{
cellMask = 7;
return 11f;
}
int num4 = 0;
for (int i = 0; i < 3; i++)
{
if (grid[i] == 1)
{
num4++;
cellMask |= 1 << i;
}
}
if (num4 > 0)
{
return SevensPay.CHERRY_PAYS[num4 - 1];
}
cellMask = 0;
return 0f;
}
public static float SpinOnce(Random rng)
{
int[] array = new int[3];
for (int i = 0; i < 3; i++)
{
array[i] = PureRng.WeightedIndex(rng, SevensPay.WEIGHTS);
}
int cellMask;
return Evaluate(array, out cellMask);
}
}
public static class JokersWildLogic
{
public static float Evaluate(int[] grid, out int cellMask)
{
cellMask = 0;
float num = 0f;
int length = JokersPay.LINES.GetLength(0);
for (int i = 0; i < length; i++)
{
int a = grid[JokersPay.LINES[i, 0]];
int b = grid[3 + JokersPay.LINES[i, 1]];
int c = grid[6 + JokersPay.LINES[i, 2]];
float num2 = EvalLine(a, b, c);
if (num2 > 0f)
{
num += num2;
cellMask |= 1 << JokersPay.LINES[i, 0];
cellMask |= 1 << 3 + JokersPay.LINES[i, 1];
cellMask |= 1 << 6 + JokersPay.LINES[i, 2];
}
}
return num;
}
private static float EvalLine(int a, int b, int c)
{
int num = 5;
int num2 = 0;
int num3 = -1;
bool flag = true;
for (int i = 0; i < 3; i++)
{
int num4 = i switch
{
1 => b,
0 => a,
_ => c,
};
if (num4 == num)
{
num2++;
}
else if (num3 < 0)
{
num3 = num4;
}
else if (num4 != num3)
{
flag = false;
}
}
if (num2 == 3)
{
return JokersPay.PAY3[num];
}
if (!flag)
{
return 0f;
}
return JokersPay.PAY3[num3];
}
public static float SpinOnce(Random rng)
{
int[] array = new int[9];
for (int i = 0; i < array.Length; i++)
{
array[i] = PureRng.WeightedIndex(rng, JokersPay.WEIGHTS);
}
int cellMask;
return Evaluate(array, out cellMask);
}
}
public class MoreSlots : GameCoreBase
{
private const int ModeNeon = 0;
private const int ModeSevens = 1;
private const int ModeDeep = 2;
private const int ModeJokers = 3;
private const int ModeScratch = 4;
private const int ModePoker = 5;
private const int ModeDeuces = 6;
private const int ModeCount = 7;
private static readonly int[] CellsAll15 = new int[15]
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14
};
private static readonly int[] CellsMid3 = new int[3] { 4, 7, 10 };
private static readonly int[] Cells3x3 = new int[9] { 3, 4, 5, 6, 7, 8, 9, 10, 11 };
private static readonly int[] CellsMid5 = new int[5] { 1, 4, 7, 10, 13 };
public SpriteRenderer[] cellSymbols;
public GameObject[] covers;
public GameObject[] holdMarkers;
public GameObject[] neonSymbols;
public GameObject[] sevensSymbols;
public GameObject[] deepSymbols;
public GameObject[] jokerSymbols;
public GameObject[] scratchSymbols;
public GameObject[] cardSymbols;
public GameObject cardBackObject;
public GameObject titleTextObject;
public GameObject winTextObject;
private int mode;
private int[] scratchCard;
private float scratchMult;
private bool[] scratchRevealed;
private int scratchRevealCount;
private int[] deck = new int[52];
private int deckPos;
private int[] hand = new int[5];
private bool[] held = new bool[5];
private bool pokerHoldPhase;
private Coroutine watchdog;
private int modeClient = -1;
private bool[] heldClient = new bool[5];
private int scratchRevealedClient;
private float scratchMultClient;
private Coroutine visualRoutine;
private Coroutine highlightRoutine;
private Sprite[][] modeSprites;
private Sprite backSprite;
private TMP_Text winText;
private TMP_Text titleText;
private TMP_Text rulesText;
private Vector3[] cellBaseScales;
private Random visualRng = new Random();
private static int[] ModeCells(int m)
{
return m switch
{
0 => CellsAll15,
1 => CellsMid3,
2 => CellsMid3,
3 => Cells3x3,
4 => Cells3x3,
_ => CellsMid5,
};
}
private static string TitleOf(int m)
{
return m switch
{
0 => "NEON NIGHTS",
1 => "LUCKY 777",
2 => "DEEP SEA SPINS",
3 => "JOKER'S WILD",
4 => "SCRATCH 'N WIN",
6 => "DEUCES WILD",
_ => "JACKS OR BETTER",
};
}
private static string RulesOf(int m)
{
return m switch
{
0 => "5 LINES: ROWS + DIAGONALS\nPAYS 3 / 4 / 5 OF A KIND (x BET)\n\nCHERRY 2.5 / 6 / 25\nLEMON 4 / 10 / 40\nGRAPE 5 / 16 / 65\nMELON 8 / 25 / 100\nBELL 13 / 50 / 200\nSTAR 19 / 80 / 325\nDIAMOND 30 / 125 / 650\nSEVEN 65 / 325 / 8625",
1 => "3 ON THE LINE PAYS (x BET)\n\nBAR x3 25\nBAR BAR x3 65\n7 x3 575\nDIAMOND x3 1725\nMIXED BARS 11\nMIXED 7 / DIAMOND 125\nCHERRIES 1=1 2=2.5 3=11",
2 => "MATCH 3 TO WIN (x BET)\n\nSHELL 9\nCRAB 16\nFISH 25\nOCTOPUS 45\nANCHOR 125\nPEARL 475\nPEARLS 1=1.5 2=6",
3 => "5 LINES: ROWS + DIAGONALS\nJOKER IS WILD\n3 ON A LINE PAYS (x BET)\n\nSPADE 1.5\nHEART 2\nCLUB 2.5\nDIAMOND 3\nCROWN 8\nJOKER 55",
4 => "MATCH 3 SYMBOLS TO WIN (x BET)\n\nCOIN 1\nBELL 2\nSHOE 5\nCLOVER 10\nGEM 25\n7 100",
6 => "ALL 2s ARE WILD\nDEAL 5 - CLICK CARDS TO HOLD - DRAW\nPAYS (x BET)\n\nNATURAL ROYAL 250\nFOUR DEUCES 200\nWILD ROYAL 25\nFIVE OF A KIND 15\nSTRAIGHT FLUSH 10\n4 OF A KIND 5.5\nFULL HOUSE 3.5\nFLUSH 2.5\nSTRAIGHT 2.5\n3 OF A KIND 1.2",
_ => "DEAL 5 - CLICK CARDS TO HOLD - DRAW\nPAYS (x BET)\n\nROYAL FLUSH 250\nSTRAIGHT FLUSH 60\n4 OF A KIND 25\nFULL HOUSE 10\nFLUSH 7\nSTRAIGHT 5\n3 OF A KIND 3\nTWO PAIR 2\nJACKS OR BETTER 1.5",
};
}
private static bool IsSlotMode(int m)
{
if (m != 0 && m != 1 && m != 2)
{
return m == 3;
}
return true;
}
private static bool IsPokerMode(int m)
{
if (m != 5)
{
return m == 6;
}
return true;
}
private static int ReelsOf(int m)
{
return m switch
{
0 => 5,
3 => 3,
_ => 3,
};
}
private static int RowsOf(int m)
{
return m switch
{
0 => 3,
3 => 3,
_ => 1,
};
}
private static int[] WeightsOf(int m)
{
return m switch
{
0 => NeonPay.WEIGHTS,
1 => SevensPay.WEIGHTS,
2 => DeepSeaPay.WEIGHTS,
_ => JokersPay.WEIGHTS,
};
}
private static float SpinBaseOf(int m)
{
return m switch
{
0 => 1.2f,
1 => 1f,
2 => 1f,
_ => 1f,
};
}
private static float SpinStaggerOf(int m)
{
return m switch
{
0 => 0.35f,
1 => 0.5f,
2 => 0.45f,
_ => 0.45f,
};
}
private static float EvaluateSlot(int m, int[] grid, out int mask)
{
return m switch
{
0 => NeonSlotsLogic.Evaluate(grid, out mask),
1 => JackpotSevensLogic.Evaluate(grid, out mask),
2 => DeepSeaSlotsLogic.Evaluate(grid, out mask),
_ => JokersWildLogic.Evaluate(grid, out mask),
};
}
private void Start()
{
CacheVisuals();
if (modeClient < 0)
{
ApplyMode(0);
}
}
private static Sprite[] SpritesFrom(GameObject[] sources)
{
if (sources == null)
{
return (Sprite[])(object)new Sprite[0];
}
Sprite[] array = (Sprite[])(object)new Sprite[sources.Length];
for (int i = 0; i < sources.Length; i++)
{
if (!((Object)(object)sources[i] == (Object)null))
{
SpriteRenderer val = sources[i].GetComponent<SpriteRenderer>();
if ((Object)(object)val == (Object)null)
{
val = sources[i].GetComponentInChildren<SpriteRenderer>(true);
}
if ((Object)(object)val != (Object)null)
{
array[i] = val.sprite;
}
}
}
return array;
}
private void CacheVisuals()
{
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_020b: Unknown result type (might be due to invalid IL or missing references)
if (modeSprites == null)
{
modeSprites = new Sprite[7][];
modeSprites[0] = SpritesFrom(neonSymbols);
modeSprites[1] = SpritesFrom(sevensSymbols);
modeSprites[2] = SpritesFrom(deepSymbols);
modeSprites[3] = SpritesFrom(jokerSymbols);
modeSprites[4] = SpritesFrom(scratchSymbols);
modeSprites[5] = SpritesFrom(cardSymbols);
modeSprites[6] = modeSprites[5];
}
if ((Object)(object)backSprite == (Object)null && (Object)(object)cardBackObject != (Object)null)
{
SpriteRenderer val = cardBackObject.GetComponent<SpriteRenderer>();
if ((Object)(object)val == (Object)null)
{
val = cardBackObject.GetComponentInChildren<SpriteRenderer>(true);
}
if ((Object)(object)val != (Object)null)
{
backSprite = val.sprite;
}
}
if ((Object)(object)winText == (Object)null && (Object)(object)winTextObject != (Object)null)
{
winText = winTextObject.GetComponent<TMP_Text>();
if ((Object)(object)winText == (Object)null)
{
winText = winTextObject.GetComponentInChildren<TMP_Text>(true);
}
}
if ((Object)(object)titleText == (Object)null && (Object)(object)titleTextObject != (Object)null)
{
titleText = titleTextObject.GetComponent<TMP_Text>();
if ((Object)(object)titleText == (Object)null)
{
titleText = titleTextObject.GetComponentInChildren<TMP_Text>(true);
}
}
if ((Object)(object)rulesText == (Object)null && (Object)(object)rulesPanel != (Object)null)
{
rulesText = rulesPanel.GetComponentInChildren<TMP_Text>(true);
}
if (cellBaseScales == null && cellSymbols != null)
{
cellBaseScales = (Vector3[])(object)new Vector3[cellSymbols.Length];
for (int i = 0; i < cellSymbols.Length; i++)
{
cellBaseScales[i] = (((Object)(object)cellSymbols[i] != (Object)null) ? ((Component)cellSymbols[i]).transform.localScale : Vector3.one);
}
}
}
private void SetWinText(string t)
{
if ((Object)(object)winText != (Object)null)
{
winText.text = t;
}
}
private GameObject CellRoot(int i)
{
if (cellSymbols == null || i >= cellSymbols.Length || (Object)(object)cellSymbols[i] == (Object)null)
{
return null;
}
Transform parent = ((Component)cellSymbols[i]).transform.parent;
if (!((Object)(object)parent != (Object)null))
{
return ((Component)cellSymbols[i]).gameObject;
}
return ((Component)parent).gameObject;
}
private void SetHoldMarkers(bool[] state)
{
if (holdMarkers == null)
{
return;
}
for (int i = 0; i < holdMarkers.Length; i++)
{
if ((Object)(object)holdMarkers[i] != (Object)null)
{
holdMarkers[i].SetActive(state != null && i < state.Length && state[i]);
}
}
}
private void ApplyMode(int m)
{
CacheVisuals();
modeClient = m;
StopVisualRoutines();
if ((Object)(object)titleText != (Object)null)
{
titleText.text = TitleOf(m);
}
if ((Object)(object)rulesText != (Object)null)
{
rulesText.text = TitleOf(m) + "\n\n" + RulesOf(m);
}
SetWinText("");
SetHoldMarkers(null);
int[] array = ModeCells(m);
Sprite[] array2 = modeSprites[m];
for (int i = 0; i < 15; i++)
{
GameObject val = CellRoot(i);
bool active = Array.IndexOf(array, i) >= 0;
if ((Object)(object)val != (Object)null)
{
val.SetActive(active);
}
if (covers != null && i < covers.Length && (Object)(object)covers[i] != (Object)null)
{
covers[i].SetActive(false);
}
}
for (int j = 0; j < array.Length; j++)
{
int num = array[j];
if (cellSymbols == null || (Object)(object)cellSymbols[num] == (Object)null)
{
continue;
}
if (IsPokerMode(m))
{
cellSymbols[num].sprite = backSprite;
}
else if (m == 4)
{
cellSymbols[num].sprite = null;
if (covers != null && (Object)(object)covers[num] != (Object)null)
{
covers[num].SetActive(true);
}
}
else if (array2.Length != 0)
{
cellSymbols[num].sprite = array2[j % array2.Length];
}
}
}
public override void OnStartServer()
{
((GameBase)this).OnStartServer();
((MonoBehaviour)this).StartCoroutine(ModeHeartbeat());
}
private IEnumerator ModeHeartbeat()
{
while (true)
{
if (NetworkServer.active)
{
BroadcastString("UserRpcMode", mode.ToString());
}
yield return (object)new WaitForSeconds(5f);
}
}
[Server]
public void SwapGame(PlayerInteract interact = null)
{
if (NetworkServer.active && !((GameBase)this).isPlaying)
{
mode = (mode + 1) % 7;
BroadcastString("UserRpcMode", mode.ToString());
}
}
public void UserRpcMode(string networkText)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (NetworkClient.active)
{
int num = GameCoreBase.PI(networkText);
if (num >= 0 && num < 7 && num != modeClient)
{
ApplyMode(num);
Sfx.Play(((Component)this).transform.position, "KeypadButton", "GenericKeypadButton");
}
}
}
protected override void StartGame()
{
GuardStuckReset();
((GameBase)this).StartGame();
if (((NetworkBehaviour)this).isServer)
{
if (watchdog != null)
{
((MonoBehaviour)this).StopCoroutine(watchdog);
watchdog = null;
}
((GameBase)this).isPlaying = true;
if (IsSlotMode(mode))
{
ServerSpin();
}
else if (mode == 4)
{
ServerScratchStart();
}
else
{
ServerDeal();
}
}
}
private void ServerSpin()
{
int num = ReelsOf(mode);
int num2 = RowsOf(mode);
int num3 = num * num2;
int[] array = new int[num3];
for (int i = 0; i < num3; i++)
{
array[i] = WeightedIndex(WeightsOf(mode));
}
int mask;
float num4 = EvaluateSlot(mode, array, out mask);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(mode).Append('|');
for (int j = 0; j < num3; j++)
{
if (j > 0)
{
stringBuilder.Append(',');
}
stringBuilder.Append(array[j]);
}
stringBuilder.Append('|').Append(GameCoreBase.F(num4)).Append('|')
.Append(mask);
BroadcastString("UserRpcSpin", stringBuilder.ToString());
float delay = SpinBaseOf(mode) + SpinStaggerOf(mode) * (float)(num - 1) + 1f;
FinishRound(num4, delay);
}
public void UserRpcSpin(string networkText)
{
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkClient.active)
{
return;
}
string[] array = networkText.Split('|');
if (array.Length < 4)
{
return;
}
int num = GameCoreBase.PI(array[0]);
if (!IsSlotMode(num))
{
return;
}
if (num != modeClient)
{
ApplyMode(num);
}
int num2 = ReelsOf(num);
int num3 = RowsOf(num);
string[] array2 = array[1].Split(',');
if (array2.Length == num2 * num3)
{
int[] array3 = new int[array2.Length];
for (int i = 0; i < array2.Length; i++)
{
array3[i] = GameCoreBase.PI(array2[i]);
}
float mult = GameCoreBase.PF(array[2]);
int mask = GameCoreBase.PI(array[3]);
((GameBase)this).isPlaying = true;
StopVisualRoutines();
SetWinText("GOOD LUCK");
Sfx.Play(((Component)this).transform.position, "SlotMachinePull", "SlotMachineSpin");
visualRoutine = ((MonoBehaviour)this).StartCoroutine(SpinAll(num, array3, mult, mask));
}
}
private IEnumerator SpinAll(int m, int[] grid, float mult, int mask)
{
int reels = ReelsOf(m);
int rows = RowsOf(m);
int[] map = ModeCells(m);
Sprite[] sprites = modeSprites[m];
float spinBase = SpinBaseOf(m);
float stagger = SpinStaggerOf(m);
float elapsed = 0f;
float tick = 0f;
int landed = 0;
bool[] reelDone = new bool[reels];
for (int i = 0; i < reels; i++)
{
Sfx.PlayParam(((Component)this).transform.position, "spinDuration", (spinBase + stagger * (float)i) * 1000f, "SlotMachineSpin 2");
}
while (landed < reels)
{
elapsed += Time.deltaTime;
tick += Time.deltaTime;
bool flag = tick >= 0.06f;
if (flag)
{
tick = 0f;
}
for (int j = 0; j < reels; j++)
{
if (reelDone[j])
{
continue;
}
if (elapsed >= spinBase + stagger * (float)j)
{
reelDone[j] = true;
landed++;
for (int k = 0; k < rows; k++)
{
int num = j * rows + k;
SpriteRenderer val = cellSymbols[map[num]];
if ((Object)(object)val != (Object)null && grid[num] >= 0 && grid[num] < sprites.Length)
{
val.sprite = sprites[grid[num]];
((MonoBehaviour)this).StartCoroutine(LandBounce(((Component)val).transform, map[num]));
}
}
Sfx.Play(((Component)this).transform.position, "SlotMachineSpinDone", "GenericKeypadButton");
}
else
{
if (!flag)
{
continue;
}
for (int l = 0; l < rows; l++)
{
SpriteRenderer val2 = cellSymbols[map[j * rows + l]];
if ((Object)(object)val2 != (Object)null && sprites.Length != 0)
{
val2.sprite = sprites[visualRng.Next(sprites.Length)];
}
}
}
}
yield return null;
}
yield return (object)new WaitForSeconds(0.25f);
float value = Mathf.Clamp(mult, 0f, 1000f);
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineMultReveal");
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineCashReveal");
if (mult > 0f)
{
SetWinText("WIN " + GameCoreBase.F(mult) + "x");
int num2 = 0;
for (int n = 0; n < map.Length; n++)
{
if ((mask & (1 << n)) != 0)
{
num2 |= 1 << map[n];
}
}
if (highlightRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(highlightRoutine);
}
highlightRoutine = ((MonoBehaviour)this).StartCoroutine(HighlightCells(num2));
}
else
{
SetWinText("NO WIN");
}
}
private IEnumerator LandBounce(Transform t, int cellIndex)
{
Vector3 baseScale = ((cellBaseScales != null) ? cellBaseScales[cellIndex] : t.localScale);
float dur = 0.18f;
float e = 0f;
while (e < dur)
{
e += Time.deltaTime;
float num = 1f + 0.18f * Mathf.Sin(Mathf.Clamp01(e / dur) * (float)Math.PI);
t.localScale = baseScale * num;
yield return null;
}
t.localScale = baseScale;
}
private IEnumerator HighlightCells(int uniMask)
{
float e = 0f;
while (e < 1.8f)
{
e += Time.deltaTime;
float num = 1f + 0.14f * Mathf.Abs(Mathf.Sin(e * 6f));
for (int i = 0; i < 15; i++)
{
if ((uniMask & (1 << i)) != 0 && !((Object)(object)cellSymbols[i] == (Object)null))
{
((Component)cellSymbols[i]).transform.localScale = cellBaseScales[i] * num;
}
}
yield return null;
}
RestoreCellScales();
}
private void RestoreCellScales()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if (cellSymbols == null || cellBaseScales == null)
{
return;
}
for (int i = 0; i < cellSymbols.Length; i++)
{
if ((Object)(object)cellSymbols[i] != (Object)null)
{
((Component)cellSymbols[i]).transform.localScale = cellBaseScales[i];
}
}
}
private void ServerScratchStart()
{
scratchCard = new int[9];
scratchMult = ScratchLogic.Generate(serverRng, ScratchPay.TIER_MULT, ScratchPay.TIER_PROB, ScratchPay.TIER_SYM, 6, scratchCard);
scratchRevealed = new bool[9];
scratchRevealCount = 0;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(mode).Append('|');
for (int i = 0; i < 9; i++)
{
if (i > 0)
{
stringBuilder.Append(',');
}
stringBuilder.Append(scratchCard[i]);
}
stringBuilder.Append('|').Append(GameCoreBase.F(scratchMult));
BroadcastString("UserRpcCard", stringBuilder.ToString());
watchdog = ((MonoBehaviour)this).StartCoroutine(ScratchWatchdog());
}
[Server]
private void RevealCell(int li)
{
if (!NetworkServer.active || !((GameBase)this).isPlaying || mode != 4 || scratchRevealed == null || li < 0 || li >= 9 || scratchRevealed[li])
{
return;
}
scratchRevealed[li] = true;
scratchRevealCount++;
BroadcastString("UserRpcReveal", li.ToString());
if (scratchRevealCount >= 9)
{
if (watchdog != null)
{
((MonoBehaviour)this).StopCoroutine(watchdog);
watchdog = null;
}
FinishRound(scratchMult, 1.2f);
}
}
private IEnumerator ScratchWatchdog()
{
yield return (object)new WaitForSeconds(45f);
for (int i = 0; i < 9; i++)
{
if (!((GameBase)this).isPlaying)
{
yield break;
}
if (!scratchRevealed[i])
{
RevealCell(i);
yield return (object)new WaitForSeconds(0.15f);
}
}
watchdog = null;
}
public void UserRpcCard(string networkText)
{
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkClient.active)
{
return;
}
string[] array = networkText.Split('|');
if (array.Length < 3)
{
return;
}
int num = GameCoreBase.PI(array[0]);
if (num != 4)
{
return;
}
if (num != modeClient)
{
ApplyMode(num);
}
string[] array2 = array[1].Split(',');
if (array2.Length != 9)
{
return;
}
int[] array3 = ModeCells(4);
Sprite[] array4 = modeSprites[4];
for (int i = 0; i < 9; i++)
{
int num2 = GameCoreBase.PI(array2[i]);
if ((Object)(object)cellSymbols[array3[i]] != (Object)null && num2 >= 0 && num2 < array4.Length)
{
cellSymbols[array3[i]].sprite = array4[num2];
}
if (covers != null && (Object)(object)covers[array3[i]] != (Object)null)
{
covers[array3[i]].SetActive(true);
}
}
scratchMultClient = GameCoreBase.PF(array[2]);
scratchRevealedClient = 0;
((GameBase)this).isPlaying = true;
SetWinText("SCRATCH!");
Sfx.Play(((Component)this).transform.position, "CardScannerButton", "GenericKeypadButton");
}
public void UserRpcReveal(string networkText)
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkClient.active)
{
return;
}
int num = GameCoreBase.PI(networkText);
int[] array = ModeCells(4);
if (num < 0 || num >= 9)
{
return;
}
GameObject val = ((covers != null) ? covers[array[num]] : null);
if (!((Object)(object)val == (Object)null) && val.activeSelf)
{
((MonoBehaviour)this).StartCoroutine(RevealAnim(val));
Sfx.Play(val.transform.position, "SlotMachineCashReveal", "GenericKeypadButton");
scratchRevealedClient++;
if (scratchRevealedClient >= 9)
{
((MonoBehaviour)this).StartCoroutine(ScratchResultAfter(0.6f));
}
}
}
private IEnumerator RevealAnim(GameObject cover)
{
Vector3 baseScale = cover.transform.localScale;
float dur = 0.25f;
float e = 0f;
while (e < dur && (Object)(object)cover != (Object)null)
{
e += Time.deltaTime;
float num = 1f - Mathf.Clamp01(e / dur);
cover.transform.localScale = new Vector3(baseScale.x * num, baseScale.y, baseScale.z);
yield return null;
}
if ((Object)(object)cover != (Object)null)
{
cover.SetActive(false);
cover.transform.localScale = baseScale;
}
}
private IEnumerator ScratchResultAfter(float delay)
{
yield return (object)new WaitForSeconds(delay);
float value = Mathf.Clamp(scratchMultClient, 0f, 1000f);
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineMultReveal");
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineCashReveal");
if (scratchMultClient > 0f)
{
SetWinText("WIN " + GameCoreBase.F(scratchMultClient) + "x");
}
else
{
SetWinText("NO WIN");
}
}
private void ServerDeal()
{
VideoPokerLogic.Shuffle(serverRng, deck);
for (int i = 0; i < 5; i++)
{
hand[i] = deck[i];
held[i] = false;
}
deckPos = 5;
pokerHoldPhase = true;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(mode).Append('|');
for (int j = 0; j < 5; j++)
{
if (j > 0)
{
stringBuilder.Append(',');
}
stringBuilder.Append(hand[j]);
}
BroadcastString("UserRpcDeal", stringBuilder.ToString());
watchdog = ((MonoBehaviour)this).StartCoroutine(PokerWatchdog());
}
[Server]
private void ToggleHold(int i)
{
if (NetworkServer.active && ((GameBase)this).isPlaying && IsPokerMode(mode) && pokerHoldPhase)
{
held[i] = !held[i];
BroadcastString("UserRpcHold", i + "," + (held[i] ? "1" : "0"));
}
}
[Server]
public void DoDraw(PlayerInteract interact = null)
{
if (!NetworkServer.active || !((GameBase)this).isPlaying || !IsPokerMode(mode) || !pokerHoldPhase)
{
return;
}
pokerHoldPhase = false;
if (watchdog != null)
{
((MonoBehaviour)this).StopCoroutine(watchdog);
watchdog = null;
}
int num = 0;
for (int i = 0; i < 5; i++)
{
if (held[i])
{
num |= 1 << i;
}
else
{
hand[i] = deck[deckPos++];
}
}
int num2;
int winMask;
float num3;
if (mode == 6)
{
num2 = DeucesWildLogic.Evaluate(hand, out winMask);
num3 = DeucesPay.PAYS[num2];
}
else
{
num2 = VideoPokerLogic.Evaluate(hand, out winMask);
num3 = PokerPay.PAYS[num2];
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(mode).Append('|');
for (int j = 0; j < 5; j++)
{
if (j > 0)
{
stringBuilder.Append(',');
}
stringBuilder.Append(hand[j]);
}
stringBuilder.Append('|').Append(GameCoreBase.F(num3)).Append('|')
.Append(num2)
.Append('|')
.Append(num);
BroadcastString("UserRpcDraw", stringBuilder.ToString());
FinishRound(num3, 1.9f);
}
private IEnumerator PokerWatchdog()
{
yield return (object)new WaitForSeconds(45f);
watchdog = null;
if (!((GameBase)this).isPlaying || !pokerHoldPhase)
{
yield break;
}
int num = ((mode == 6) ? DeucesWildLogic.HoldMask(hand) : VideoPokerLogic.HoldMask(hand));
for (int i = 0; i < 5; i++)
{
bool flag = (num & (1 << i)) != 0;
if (held[i] != flag)
{
ToggleHold(i);
}
}
yield return (object)new WaitForSeconds(0.4f);
DoDraw();
}
public void UserRpcDeal(string networkText)
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkClient.active)
{
return;
}
string[] array = networkText.Split('|');
if (array.Length < 2)
{
return;
}
int num = GameCoreBase.PI(array[0]);
if (!IsPokerMode(num))
{
return;
}
if (num != modeClient)
{
ApplyMode(num);
}
string[] array2 = array[1].Split(',');
if (array2.Length == 5)
{
((GameBase)this).isPlaying = true;
for (int i = 0; i < 5; i++)
{
heldClient[i] = false;
}
SetHoldMarkers(null);
SetWinText("HOLD CARDS, THEN DRAW");
Sfx.Play(((Component)this).transform.position, "SlotMachinePull", "GenericKeypadButton");
if (visualRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(visualRoutine);
}
visualRoutine = ((MonoBehaviour)this).StartCoroutine(FlipCards(array2, 31));
}
}
public void UserRpcHold(string networkText)
{
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkClient.active)
{
return;
}
string[] array = networkText.Split(',');
if (array.Length != 2)
{
return;
}
int num = GameCoreBase.PI(array[0]);
if (num >= 0 && num < 5)
{
heldClient[num] = array[1] == "1";
if (holdMarkers != null && num < holdMarkers.Length && (Object)(object)holdMarkers[num] != (Object)null)
{
holdMarkers[num].SetActive(heldClient[num]);
}
Sfx.Play(((Component)this).transform.position, "KeypadButton", "GenericKeypadButton");
}
}
public void UserRpcDraw(string networkText)
{
if (!NetworkClient.active)
{
return;
}
string[] array = networkText.Split('|');
if (array.Length < 5)
{
return;
}
int num = GameCoreBase.PI(array[0]);
if (!IsPokerMode(num))
{
return;
}
if (num != modeClient)
{
ApplyMode(num);
}
string[] array2 = array[1].Split(',');
if (array2.Length == 5)
{
float mult = GameCoreBase.PF(array[2]);
int cat = GameCoreBase.PI(array[3]);
int num2 = GameCoreBase.PI(array[4]);
if (visualRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(visualRoutine);
}
visualRoutine = ((MonoBehaviour)this).StartCoroutine(DrawAndReveal(num, array2, ~num2 & 0x1F, mult, cat));
}
}
private IEnumerator DrawAndReveal(int m, string[] cells, int flipMask, float mult, int cat)
{
yield return FlipCards(cells, flipMask);
yield return (object)new WaitForSeconds(0.25f);
float value = Mathf.Clamp(mult, 0f, 1000f);
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineMultReveal");
Sfx.PlayParam(((Component)this).transform.position, "Multiplier", value, "SlotMachineCashReveal");
string[] array = ((m == 6) ? DeucesPay.NAMES : PokerPay.NAMES);
if (mult > 0f && cat > 0 && cat < array.Length)
{
SetWinText(array[cat] + " " + GameCoreBase.F(mult) + "x");
}
else
{
SetWinText("NO WIN");
}
}
private IEnumerator FlipCards(string[] cells, int mask)
{
int[] map = ModeCells(5);
Sprite[] sprites = modeSprites[5];
for (int i = 0; i < 5; i++)
{
if ((mask & (1 << i)) != 0)
{
SpriteRenderer val = cellSymbols[map[i]];
if (!((Object)(object)val == (Object)null))
{
int num = GameCoreBase.PI(cells[i]);
yield return FlipOne(val, map[i], (num >= 0 && num < sprites.Length) ? sprites[num] : null);
yield return (object)new WaitForSeconds(0.14f);
}
}
}
}
private IEnumerator FlipOne(SpriteRenderer sr, int cellIndex, Sprite target)
{
Transform t = ((Component)sr).transform;
Vector3 baseScale = ((cellBaseScales != null) ? cellBaseScales[cellIndex] : t.localScale);
float dur = 0.09f;
for (float e = 0f; e < dur; e += Time.deltaTime)
{
float num = 1f - Mathf.Clamp01(e / dur);
t.localScale = new Vector3(baseScale.x * num, baseScale.y, baseScale.z);
yield return null;
}
if ((Object)(object)target != (Object)null)
{
sr.sprite = target;
}
Sfx.Play(t.position, "SlotMachineSpinDone", "GenericKeypadButton");
for (float e = 0f; e < dur; e += Time.deltaTime)
{
float num2 = Mathf.Clamp01(e / dur);
t.localScale = new Vector3(baseScale.x * num2, baseScale.y, baseScale.z);
yield return null;
}
t.localScale = baseScale;
}
[Server]
private void CellPressed(int uni)
{
if (!NetworkServer.active || !((GameBase)this).isPlaying)
{
return;
}
if (mode == 4)
{
int num = Array.IndexOf(ModeCells(4), uni);
if (num >= 0)
{
RevealCell(num);
}
}
else if (IsPokerMode(mode))
{
int num2 = Array.IndexOf(ModeCells(5), uni);
if (num2 >= 0)
{
ToggleHold(num2);
}
}
}
[Server]
public void CellPressed0(PlayerInteract interact = null)
{
CellPressed(0);
}
[Server]
public void CellPressed1(PlayerInteract interact = null)
{
CellPressed(1);
}
[Server]
public void CellPressed2(PlayerInteract interact = null)
{
CellPressed(2);
}
[Server]
public void CellPressed3(PlayerInteract interact = null)
{
CellPressed(3);
}
[Server]
public void CellPressed4(PlayerInteract interact = null)
{
CellPressed(4);
}
[Server]
public void CellPressed5(PlayerInteract interact = null)
{
CellPressed(5);
}
[Server]
public void CellPressed6(PlayerInteract interact = null)
{
CellPressed(6);
}
[Server]
public void CellPressed7(PlayerInteract interact = null)
{
CellPressed(7);
}
[Server]
public void CellPressed8(PlayerInteract interact = null)
{
CellPressed(8);
}
[Server]
public void CellPressed9(PlayerInteract interact = null)
{
CellPressed(9);
}
[Server]
public void CellPressed10(PlayerInteract interact = null)
{
CellPressed(10);
}
[Server]
public void CellPressed11(PlayerInteract interact = null)
{
CellPressed(11);
}
[Server]
public void CellPressed12(PlayerInteract interact = null)
{
CellPressed(12);
}
[Server]
public void CellPressed13(PlayerInteract interact = null)
{
CellPressed(13);
}
[Server]
public void CellPressed14(PlayerInteract interact = null)
{
CellPressed(14);
}
private void StopVisualRoutines()
{
if (visualRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(visualRoutine);
visualRoutine = null;
}
if (highlightRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(highlightRoutine);
highlightRoutine = null;
}
RestoreCellScales();
}
protected override void OnClientResetVisuals()
{
StopVisualRoutines();
((GameBase)this).isPlaying = false;
int m = ((modeClient >= 0) ? modeClient : 0);
modeClient = -1;
ApplyMode(m);
}
}
public static class NeonSlotsLogic
{
public static float Evaluate(int[] grid, out int cellMask)
{
cellMask = 0;
float num = 0f;
int length = NeonPay.LINES.GetLength(0);
for (int i = 0; i < length; i++)
{
int num2 = grid[NeonPay.LINES[i, 0]];
int num3 = 1;
for (int j = 1; j < 5 && grid[j * 3 + NeonPay.LINES[i, j]] == num2; j++)
{
num3++;
}
if (num3 >= 3)
{
num += num3 switch
{
3 => NeonPay.PAY3[num2],
4 => NeonPay.PAY4[num2],
_ => NeonPay.PAY5[num2],
};
for (int k = 0; k < num3; k++)
{
cellMask |= 1 << k * 3 + NeonPay.LINES[i, k];
}
}
}
return num;
}
public static float SpinOnce(Random rng)
{
int[] array = new int[15];
for (int i = 0; i < array.Length; i++)
{
array[i] = PureRng.WeightedIndex(rng, NeonPay.WEIGHTS);
}
int cellMask;
return Evaluate(array, out cellMask);
}
}
internal static class NeonPay
{
public const string TITLE = "NEON NIGHTS";
public const string RULES = "5 LINES: ROWS + DIAGONALS\nPAYS 3 / 4 / 5 OF A KIND (x BET)\n\nCHERRY 2.5 / 6 / 25\nLEMON 4 / 10 / 40\nGRAPE 5 / 16 / 65\nMELON 8 / 25 / 100\nBELL 13 / 50 / 200\nSTAR 19 / 80 / 325\nDIAMOND 30 / 125 / 650\nSEVEN 65 / 325 / 8625";
public const int REELS = 5;
public const int ROWS = 3;
public const float SPIN_BASE = 1.2f;
public const float SPIN_STAGGER = 0.35f;
public static readonly int[] WEIGHTS = new int[8] { 25, 20, 16, 12, 10, 8, 6, 3 };
public static readonly float[] PAY3 = new float[8] { 2.5f, 4f, 5f, 8f, 13f, 19f, 30f, 65f };
public static readonly float[] PAY4 = new float[8] { 6f, 10f, 16f, 25f, 50f, 80f, 125f, 325f };
public static readonly float[] PAY5 = new float[8] { 25f, 40f, 65f, 100f, 200f, 325f, 650f, 8625f };
public static readonly int[,] LINES = new int[5, 5]
{
{ 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0 },
{ 2, 2, 2, 2, 2 },
{ 0, 1, 2, 1, 0 },
{ 2, 1, 0, 1, 2 }
};
}
internal static class SevensPay
{
public const string TITLE = "LUCKY 777";
public const string RULES = "3 ON THE LINE PAYS (x BET)\n\nBAR x3 25\nBAR BAR x3 65\n7 x3 575\nDIAMOND x3 1725\nMIXED BARS 11\nMIXED 7 / DIAMOND 125\nCHERRIES 1=1 2=2.5 3=11";
public const float SPIN_BASE = 1f;
public const float SPIN_STAGGER = 0.5f;
public static readonly int[] WEIGHTS = new int[6] { 50, 12, 18, 10, 7, 3 };
public static readonly float[] TRIPLE = new float[6] { 0f, 0f, 25f, 65f, 575f, 1725f };
public static readonly float[] CHERRY_PAYS = new float[3] { 1f, 2.5f, 11f };
public const float ANY_BAR = 11f;
public const float SEVEN_DIAMOND_MIX = 125f;
public const int CHERRY = 1;
public const int BAR = 2;
public const int DBAR = 3;
public const int SEVEN = 4;
public const int JDIAMOND = 5;
}
internal static class DeepSeaPay
{
public const string TITLE = "DEEP SEA SPINS";
public const string RULES = "MATCH 3 TO WIN (x BET)\n\nSHELL 9\nCRAB 16\nFISH 25\nOCTOPUS 45\nANCHOR 125\nPEARL 475\nPEARLS 1=1.5 2=6";
public const float SPIN_BASE = 1f;
public const float SPIN_STAGGER = 0.45f;
public static readonly int[] WEIGHTS = new int[6] { 30, 25, 20, 12, 9, 4 };
public static readonly float[] PAY3 = new float[6] { 9f, 16f, 25f, 45f, 125f, 475f };
public const int PEARL = 5;
public const float PEARL_1 = 1.5f;
public const float PEARL_2 = 6f;
}
internal static class JokersPay
{
public const string TITLE = "JOKER'S WILD";
public const string RULES = "5 LINES: ROWS + DIAGONALS\nJOKER IS WILD\n3 ON A LINE PAYS (x BET)\n\nSPADE 1.5\nHEART 2\nCLUB 2.5\nDIAMOND 3\nCROWN 8\nJOKER 55";
public const int REELS = 3;
public const int ROWS = 3;
public const float SPIN_BASE = 1f;
public const float SPIN_STAGGER = 0.45f;
public static readonly int[] WEIGHTS = new int[6] { 22, 20, 18, 14, 10, 6 };
public static readonly float[] PAY3 = new float[6] { 1.5f, 2f, 2.5f, 3f, 8f, 55f };
public const int WILD = 5;
public static readonly int[,] LINES = new int[5, 3]
{
{ 1, 1, 1 },
{ 0, 0, 0 },
{ 2, 2, 2 },
{ 0, 1, 2 },
{ 2, 1, 0 }
};
}
internal static class ScratchPay
{
public const string TITLE = "SCRATCH 'N WIN";
public const string RULES = "MATCH 3 SYMBOLS TO WIN (x BET)\n\nCOIN 1\nBELL 2\nSHOE 5\nCLOVER 10\nGEM 25\n7 100";
public const int GRID = 3;
public const int SYMBOL_COUNT = 6;
public static readonly float[] TIER_MULT = new float[7] { 0f, 1f, 2f, 5f, 10f, 25f, 100f };
public static readonly double[] TIER_PROB = new double[7] { 0.78194, 0.08722, 0.05815, 0.03877, 0.02181, 0.00969, 0.00242 };
public static readonly int[] TIER_SYM = new int[7] { -1, 0, 1, 2, 3, 4, 5 };
}
internal static class PokerPay
{
public const string TITLE = "JACKS OR BETTER";
public const string RULES = "DEAL 5 - CLICK CARDS TO HOLD - DRAW\nPAYS (x BET)\n\nROYAL FLUSH 250\nSTRAIGHT FLUSH 60\n4 OF A KIND 25\nFULL HOUSE 10\nFLUSH 7\nSTRAIGHT 5\n3 OF A KIND 3\nTWO PAIR 2\nJACKS OR BETTER 1.5";
public static readonly float[] PAYS = new float[10] { 0f, 1.5f, 2f, 3f, 5f, 7f, 10f, 25f, 60f, 250f };
public static readonly string[] NAMES = new string[10] { "", "JACKS OR BETTER", "TWO PAIR", "THREE OF A KIND", "STRAIGHT", "FLUSH", "FULL HOUSE", "FOUR OF A KIND", "STRAIGHT FLUSH", "ROYAL FLUSH" };
}
internal static class DeucesPay
{
public const string TITLE = "DEUCES WILD";
public const string RULES = "ALL 2s ARE WILD\nDEAL 5 - CLICK CARDS TO HOLD - DRAW\nPAYS (x BET)\n\nNATURAL ROYAL 250\nFOUR DEUCES 200\nWILD ROYAL 25\nFIVE OF A KIND 15\nSTRAIGHT FLUSH 10\n4 OF A KIND 5.5\nFULL HOUSE 3.5\nFLUSH 2.5\nSTRAIGHT 2.5\n3 OF A KIND 1.2";
public static readonly float[] PAYS = new float[11]
{
0f, 1.2f, 2.5f, 2.5f, 3.5f, 5.5f, 10f, 15f, 25f, 200f,
250f
};
public static readonly string[] NAMES = new string[11]
{
"", "THREE OF A KIND", "STRAIGHT", "FLUSH", "FULL HOUSE", "FOUR OF A KIND", "STRAIGHT FLUSH", "FIVE OF A KIND", "WILD ROYAL", "FOUR DEUCES",
"NATURAL ROYAL"
};
}
public static class ScratchCardLogic
{
public static float SpinOnce(Random rng)
{
int[] cells = new int[9];
return ScratchLogic.Generate(rng, ScratchPay.TIER_MULT, ScratchPay.TIER_PROB, ScratchPay.TIER_SYM, 6, cells);
}
}
public static class VideoPokerLogic
{
public const int NONE = 0;
public const int JACKS_OR_BETTER = 1;
public const int TWO_PAIR = 2;
public const int THREE_KIND = 3;
public const int STRAIGHT = 4;
public const int FLUSH = 5;
public const int FULL_HOUSE = 6;
public const int FOUR_KIND = 7;
public const int STRAIGHT_FLUSH = 8;
public const int ROYAL_FLUSH = 9;
public static int Rank(int card)
{
return card % 13;
}
public static int Suit(int card)
{
return card / 13;
}
public static int Evaluate(int[] hand, out int winMask)
{
int[] array = new int[13];
for (int i = 0; i < 5; i++)
{
array[Rank(hand[i])]++;
}
bool flag = true;
for (int j = 1; j < 5; j++)
{
if (Suit(hand[j]) != Suit(hand[0]))
{
flag = false;
break;
}
}
int num = 0;
int num2 = -1;
int num3 = -1;
int num4 = -1;
int num5 = 0;
int num6 = 13;
int num7 = -1;
for (int k = 0; k < 13; k++)
{
if (array[k] == 0)
{
continue;
}
num5++;
if (k < num6)
{
num6 = k;
}
if (k > num7)
{
num7 = k;
}
if (array[k] == 2)
{
num++;
if (k > num2)
{
num2 = k;
}
}
if (array[k] == 3)
{
num3 = k;
}
if (array[k] == 4)
{
num4 = k;
}
}
bool flag2 = false;
bool flag3 = false;
if (num5 == 5)
{
if (num7 - num6 == 4)
{
flag2 = true;
}
else if (array[12] == 1 && array[0] == 1 && array[1] == 1 && array[2] == 1 && array[3] == 1)
{
flag2 = true;
}
flag3 = flag2 && num6 == 8;
}
if (flag2 && flag)
{
winMask = 31;
if (!flag3)
{
return 8;
}
return 9;
}
if (num4 >= 0)
{
winMask = MaskOfRank(hand, num4);
return 7;
}
if (num3 >= 0 && num == 1)
{
winMask = 31;
return 6;
}
if (flag)
{
winMask = 31;
return 5;
}
if (flag2)
{
winMask = 31;
return 4;
}
if (num3 >= 0)
{
winMask = MaskOfRank(hand, num3);
return 3;
}
switch (num)
{
case 2:
{
winMask = 0;
for (int l = 0; l < 13; l++)
{
if (array[l] == 2)
{
winMask |= MaskOfRank(hand, l);
}
}
return 2;
}
case 1:
if (num2 >= 9)
{
winMask = MaskOfRank(hand, num2);
return 1;
}
break;
}
winMask = 0;
return 0;
}
private static int MaskOfRank(int[] hand, int rank)
{
int num = 0;
for (int i = 0; i < 5; i++)
{
if (Rank(hand[i]) == rank)
{
num |= 1 << i;
}
}
return num;
}
public static int HoldMask(int[] hand)
{
int winMask;
int num = Evaluate(hand, out winMask);
if (num == 9 || num == 8 || num == 7)
{
return 31;
}
int num2 = SuitedInRoyalRange(hand, 4);
if (num2 != 0)
{
return num2;
}
switch (num)
{
case 6:
return 31;
case 5:
return 31;
case 3:
return winMask;
case 4:
return 31;
default:
num2 = FourToStraightFlush(hand);
if (num2 != 0)
{
return num2;
}
switch (num)
{
case 2:
return winMask;
case 1:
return winMask;
default:
{
num2 = SuitedInRoyalRange(hand, 3);
if (num2 != 0)
{
return num2;
}
num2 = SuitedCount(hand, 4);
if (num2 != 0)
{
return num2;
}
int num3 = LowPairMask(hand);
if (num3 != 0)
{
return num3;
}
num2 = FourToStraight(hand);
if (num2 != 0)
{
return num2;
}
num2 = TwoSuitedHigh(hand);
if (num2 != 0)
{
return num2;
}
num2 = ThreeToStraightFlush(hand);
if (num2 != 0)
{
return num2;
}
num2 = LowestHighCards(hand, 2);
if (num2 != 0)
{
return num2;
}
num2 = SuitedTenHonor(hand);
if (num2 != 0)
{
return num2;
}
num2 = LowestHighCards(hand, 1);
if (num2 != 0)
{
return num2;
}
return 0;
}
}
}
}
private static int SuitedInRoyalRange(int[] hand, int need)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
for (int j = 0; j < 5; j++)
{
if (Suit(hand[j]) == i && Rank(hand[j]) >= 8)
{
num |= 1 << j;
num2++;
}
}
if (num2 >= need)
{
return num;
}
}
return 0;
}
private static int SuitedCount(int[] hand, int need)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
for (int j = 0; j < 5; j++)
{
if (Suit(hand[j]) == i)
{
num |= 1 << j;
num2++;
}
}
if (num2 >= need)
{
return num;
}
}
return 0;
}
private static int LowPairMask(int[] hand)
{
int[] array = new int[13];
for (int i = 0; i < 5; i++)
{
array[Rank(hand[i])]++;
}
for (int j = 0; j < 9; j++)
{
if (array[j] != 2)
{
continue;
}
int num = 0;
for (int k = 0; k < 5; k++)
{
if (Rank(hand[k]) == j)
{
num |= 1 << k;
}
}
return num;
}
return 0;
}
private static int FourToStraight(int[] hand)
{
for (int i = 0; i < 5; i++)
{
int num = 0;
int num2 = 0;
int num3 = 13;
int num4 = -1;
bool flag = false;
int num5 = 0;
bool flag2 = false;
bool flag3 = true;
for (int j = 0; j < 5; j++)
{
if (j != i)
{
int num6 = Rank(hand[j]);
if ((num5 & (1 << num6)) != 0)
{
flag = true;
break;
}
num5 |= 1 << num6;
num |= 1 << j;
num2++;
if (num6 < num3)
{
num3 = num6;
}
if (num6 > num4)
{
num4 = num6;
}
if (num6 == 12)
{
flag2 = true;
}
else if (num6 > 3)
{
flag3 = false;
}
}
}
if (!flag && num2 == 4)
{
if (num4 - num3 <= 4)
{
return num;
}
if (flag2 && flag3)
{
return num;
}
}
}
return 0;
}
private static int FourToStraightFlush(int[] hand)
{
return StraightFlushDraw(hand, 4);
}
private static int ThreeToStraightFlush(int[] hand)
{
return StraightFlushDraw(hand, 3);
}
private static int StraightFlushDraw(int[] hand, int need)
{
for (int i = 0; i < 4; i++)
{
int[] array = new int[5];
int num = 0;
for (int j = 0; j < 5; j++)
{
if (Suit(hand[j]) == i)
{
array[num++] = j;
}
}
if (num < need)
{
continue;
}
for (int k = 0; k < 1 << num; k++)
{
int num2 = 0;
int num3 = 0;
int num4 = 13;
int num5 = -1;
int num6 = 0;
bool flag = false;
bool flag2 = false;
bool flag3 = true;
for (int l = 0; l < num; l++)
{
if ((k & (1 << l)) != 0)
{
num2++;
int num7 = array[l];
int num8 = Rank(hand[num7]);
if ((num6 & (1 << num8)) != 0)
{
flag = true;
break;
}
num6 |= 1 << num8;
num3 |= 1 << num7;
if (num8 < num4)
{
num4 = num8;
}
if (num8 > num5)
{
num5 = num8;
}
if (num8 == 12)
{
flag2 = true;
}
else if (num8 > 3)
{
flag3 = false;
}
}
}
if (!flag && num2 == need && (num5 - num4 <= 4 || (flag2 && flag3)))
{
return num3;
}
}
}
return 0;
}
private static int TwoSuitedHigh(int[] hand)
{
for (int i = 0; i < 4; i++)
{
int num = 0;
int num2 = 0;
for (int j = 0; j < 5; j++)
{
if (Suit(hand[j]) == i && Rank(hand[j]) >= 9)
{
num |= 1 << j;
num2++;
}
}
if (num2 >= 2)
{
return num;
}
}
return 0;
}
private static int SuitedTenHonor(int[] hand)
{
for (int i = 0; i < 5; i++)
{
if (Rank(hand[i]) != 8)
{
continue;
}
for (int j = 0; j < 5; j++)
{
int num = Rank(hand[j]);
if (Suit(hand[j]) == Suit(hand[i]) && num >= 9 && num <= 11)
{
return (1 << i) | (1 << j);
}
}
}
return 0;
}
private static int LowestHighCards(int[] hand, int want)
{
int num = 0;
int num2 = 0;
for (int i = 9; i <= 12; i++)
{
if (num2 >= want)
{
break;
}
for (int j = 0; j < 5; j++)
{
if (num2 >= want)
{
break;
}
if (Rank(hand[j]) == i && (num & (1 << j)) == 0)
{
num |= 1 << j;
num2++;
}
}
}
if (num2 != want)
{
return 0;
}
return num;
}
public static void Shuffle(Random rng, int[] deck)
{
for (int i = 0; i < deck.Length; i++)
{
deck[i] = i;
}
for (int num = deck.Length - 1; num > 0; num--)
{
int num2 = rng.Next(num + 1);
int num3 = deck[num];
deck[num] = deck[num2];
deck[num2] = num3;
}
}
public static float SpinOnce(Random rng)
{
int[] array = new int[52];
Shuffle(rng, array);
int[] array2 = new int[5];
for (int i = 0; i < 5; i++)
{
array2[i] = array[i];
}
int num = HoldMask(array2);
int num2 = 5;
for (int j = 0; j < 5; j++)
{
if ((num & (1 << j)) == 0)
{
array2[j] = array[num2++];
}
}
int winMask;
int num3 = Evaluate(array2, out winMask);
return PokerPay.PAYS[num3];
}
}
}
namespace GWYFCustom.Games.PluginNS
{
[BepInPlugin("com.willikers.moreslots", "More Slots", "1.2.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class MoreSlotsPlugin : BaseUnityPlugin
{
private void Awake()
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"MoreSlots assembly loaded, waiting for MoreGames base loader.");
}
}
}
