Restructured the project structure back to the way it was, there's no reasonable way to split the modules

src/NadekoBot/_common/Gambling/Betdraw/BetdrawColorGuess.cs

@@ -0,0 +1,7 @@
+namespace Nadeko.Econ.Gambling.Betdraw;
+
+public enum BetdrawColorGuess
+{
+    Red,
+    Black
+}

src/NadekoBot/_common/Gambling/Betdraw/BetdrawGame.cs

@@ -0,0 +1,84 @@
+namespace Nadeko.Econ.Gambling.Betdraw;
+
+public sealed class BetdrawGame
+{
+    private static readonly NadekoRandom _rng = new();
+    private readonly RegularDeck _deck;
+
+    private const decimal SINGLE_GUESS_MULTI = 2.075M;
+    private const decimal DOUBLE_GUESS_MULTI = 4.15M;
+    
+    public BetdrawGame()
+    {
+        _deck = new RegularDeck();
+    }
+    
+    public BetdrawResult Draw(BetdrawValueGuess? val, BetdrawColorGuess? col, decimal amount)
+    {
+        if (val is null && col is null)
+            throw new ArgumentNullException(nameof(val));
+
+        var card = _deck.Peek(_rng.Next(0, 52))!;
+
+        var realVal = (int)card.Value < 7
+            ? BetdrawValueGuess.Low
+            : BetdrawValueGuess.High;
+
+        var realCol = card.Suit is RegularSuit.Diamonds or RegularSuit.Hearts
+            ? BetdrawColorGuess.Red
+            : BetdrawColorGuess.Black;
+        
+        // if card is 7, autoloss
+        if (card.Value == RegularValue.Seven)
+        {
+            return new()
+            {
+                Won = 0M,
+                Multiplier = 0M,
+                ResultType = BetdrawResultType.Lose,
+                Card = card,
+            };
+        }
+
+        byte win = 0;
+        if (val is BetdrawValueGuess valGuess)
+        {
+            if (realVal != valGuess)
+                return new()
+                {
+                    Won = 0M,
+                    Multiplier = 0M,
+                    ResultType = BetdrawResultType.Lose,
+                    Card = card
+                };
+
+            ++win;
+        }
+        
+        if (col is BetdrawColorGuess colGuess)
+        {
+            if (realCol != colGuess)
+                return new()
+                {
+                    Won = 0M,
+                    Multiplier = 0M,
+                    ResultType = BetdrawResultType.Lose,
+                    Card = card
+                };
+
+            ++win;
+        }
+
+        var multi = win == 1
+            ? SINGLE_GUESS_MULTI
+            : DOUBLE_GUESS_MULTI;
+
+        return new()
+        {
+            Won = amount * multi,
+            Multiplier = multi,
+            ResultType = BetdrawResultType.Win,
+            Card = card
+        };
+    }
+}

src/NadekoBot/_common/Gambling/Betdraw/BetdrawResult.cs

@@ -0,0 +1,9 @@
+namespace Nadeko.Econ.Gambling.Betdraw;
+
+public readonly struct BetdrawResult
+{
+    public decimal Won { get; init; }
+    public decimal Multiplier { get; init; }
+    public BetdrawResultType ResultType { get; init; }
+    public RegularCard Card { get; init; }
+}

src/NadekoBot/_common/Gambling/Betdraw/BetdrawResultType.cs

@@ -0,0 +1,7 @@
+namespace Nadeko.Econ.Gambling.Betdraw;
+
+public enum BetdrawResultType
+{
+    Win,
+    Lose
+}

src/NadekoBot/_common/Gambling/Betdraw/BetdrawValueGuess.cs

@@ -0,0 +1,7 @@
+namespace Nadeko.Econ.Gambling.Betdraw;
+
+public enum BetdrawValueGuess
+{
+    High,
+    Low,
+}

src/NadekoBot/_common/Gambling/Betflip/BetflipGame.cs

@@ -0,0 +1,33 @@
+namespace Nadeko.Econ.Gambling;
+
+public sealed class BetflipGame
+{
+    private readonly decimal _winMulti;
+    private static readonly NadekoRandom _rng = new NadekoRandom();
+
+    public BetflipGame(decimal winMulti)
+    {
+        _winMulti = winMulti;
+    }
+
+    public BetflipResult Flip(byte guess, decimal amount)
+    {
+        var side = (byte)_rng.Next(0, 2);
+        if (side == guess)
+        {
+            return new BetflipResult()
+            {
+                Side = side,
+                Won = amount * _winMulti,
+                Multiplier = _winMulti
+            };
+        }
+
+        return new BetflipResult()
+        {
+            Side = side,
+            Won = 0,
+            Multiplier = 0,
+        };
+    }
+}

src/NadekoBot/_common/Gambling/Betflip/BetflipResult.cs

@@ -0,0 +1,8 @@
+namespace Nadeko.Econ.Gambling;
+
+public readonly struct BetflipResult
+{
+    public decimal Won { get; init; }
+    public byte Side { get; init; }
+    public decimal Multiplier { get; init; }
+}

src/NadekoBot/_common/Gambling/Betroll/BetrollGame.cs

@@ -0,0 +1,42 @@
+namespace Nadeko.Econ.Gambling;
+
+public sealed class BetrollGame
+{
+    private readonly (int WhenAbove, decimal MultiplyBy)[] _thresholdPairs;
+    private readonly NadekoRandom _rng;
+
+    public BetrollGame(IReadOnlyList<(int WhenAbove, decimal MultiplyBy)> pairs)
+    {
+        _thresholdPairs = pairs.OrderByDescending(x => x.WhenAbove).ToArray();
+        _rng = new();
+    }
+
+    public BetrollResult Roll(decimal amount = 0)
+    {
+        var roll = _rng.Next(1, 101);
+
+        for (var i = 0; i < _thresholdPairs.Length; i++)
+        {
+            ref var pair = ref _thresholdPairs[i];
+
+            if (pair.WhenAbove < roll)
+            {
+                return new()
+                {
+                    Multiplier = pair.MultiplyBy,
+                    Roll = roll,
+                    Threshold = pair.WhenAbove,
+                    Won = amount * pair.MultiplyBy
+                };
+            }
+        }
+
+        return new()
+        {
+            Multiplier = 0,
+            Roll = roll,
+            Threshold = -1,
+            Won = 0,
+        };
+    }
+}

src/NadekoBot/_common/Gambling/Betroll/BetrollResult.cs

@@ -0,0 +1,9 @@
+namespace Nadeko.Econ.Gambling;
+
+public readonly struct BetrollResult
+{
+    public int Roll { get; init; }
+    public decimal Multiplier { get; init; }
+    public decimal Threshold { get; init; }
+    public decimal Won { get; init; }
+}

src/NadekoBot/_common/Gambling/Rps/RpsGame.cs

@@ -0,0 +1,75 @@
+namespace Nadeko.Econ.Gambling.Rps;
+
+public sealed class RpsGame
+{
+    private static readonly NadekoRandom _rng = new NadekoRandom();
+    
+    const decimal WIN_MULTI = 1.95m;
+    const decimal DRAW_MULTI = 1m;
+    const decimal LOSE_MULTI = 0m;
+    
+    public RpsGame()
+    {
+        
+    }
+    
+    public RpsResult Play(RpsPick pick, decimal amount)
+    {
+        var compPick = (RpsPick)_rng.Next(0, 3);
+        if (compPick == pick)
+        {
+            return new()
+            {
+                Won = amount * DRAW_MULTI,
+                Multiplier = DRAW_MULTI,
+                ComputerPick = compPick,
+                Result = RpsResultType.Draw,
+            };
+        }
+
+        if ((compPick == RpsPick.Paper && pick == RpsPick.Rock)
+            || (compPick == RpsPick.Rock && pick == RpsPick.Scissors)
+            || (compPick == RpsPick.Scissors && pick == RpsPick.Paper))
+        {
+            return new()
+            {
+                Won = amount * LOSE_MULTI,
+                Multiplier = LOSE_MULTI,
+                Result = RpsResultType.Lose,
+                ComputerPick = compPick,
+            };
+        }
+
+        return new()
+        {
+            Won = amount * WIN_MULTI,
+            Multiplier = WIN_MULTI,
+            Result = RpsResultType.Win,
+            ComputerPick = compPick,
+        };
+    }
+}
+
+public enum RpsPick : byte
+{
+    Rock = 0,
+    Paper = 1,
+    Scissors = 2,
+}
+
+public enum RpsResultType : byte
+{
+    Win,
+    Draw,
+    Lose
+}
+
+
+
+public readonly struct RpsResult
+{
+    public decimal Won { get; init; }
+    public decimal Multiplier { get; init; }
+    public RpsResultType Result { get; init; }
+    public RpsPick ComputerPick { get; init; }
+}

src/NadekoBot/_common/Gambling/Slot/SlotGame.cs

@@ -0,0 +1,116 @@
+namespace Nadeko.Econ.Gambling;
+
+//here is a payout chart
+//https://lh6.googleusercontent.com/-i1hjAJy_kN4/UswKxmhrbPI/AAAAAAAAB1U/82wq_4ZZc-Y/DE6B0895-6FC1-48BE-AC4F-14D1B91AB75B.jpg
+//thanks to judge for helping me with this
+public class SlotGame
+{
+    private static readonly NadekoRandom _rng = new NadekoRandom();
+
+    public SlotResult Spin(decimal bet)
+    {
+        var rolls = new[]
+        {
+            (byte)_rng.Next(0, 6),
+            (byte)_rng.Next(0, 6),
+            (byte)_rng.Next(0, 6)
+        };
+
+        ref var a = ref rolls[0];
+        ref var b = ref rolls[1];
+        ref var c = ref rolls[2];
+        
+        var multi = 0;
+        var winType = SlotWinType.None;
+        if (a == b && b == c)
+        {
+            if (a == 5)
+            {
+                winType = SlotWinType.TrippleJoker;
+                multi = 30;
+            }
+            else
+            {
+                winType = SlotWinType.TrippleNormal;
+                multi = 10;
+            }
+        }
+        else if (a == 5 && (b == 5 || c == 5)
+                 || (b == 5 && c == 5))
+        {
+            winType = SlotWinType.DoubleJoker;
+            multi = 4;
+        }
+        else if (a == 5 || b == 5 || c == 5)
+        {
+            winType = SlotWinType.SingleJoker;
+            multi = 1;
+        }
+
+        return new()
+        {
+            Won = bet * multi,
+            WinType = winType,
+            Multiplier = multi,
+            Rolls = rolls,
+        };
+    }
+}
+
+public enum SlotWinType : byte
+{
+    None,
+    SingleJoker,
+    DoubleJoker,
+    TrippleNormal,
+    TrippleJoker,
+}
+
+/*
+var rolls = new[]
+        {
+            _rng.Next(default(byte), 6),
+            _rng.Next(default(byte), 6),
+            _rng.Next(default(byte), 6)
+        };
+        
+        var multi = 0;
+        var winType = SlotWinType.None;
+
+        ref var a = ref rolls[0];
+        ref var b = ref rolls[1];
+        ref var c = ref rolls[2];
+        if (a == b && b == c)
+        {
+            if (a == 5)
+            {
+                winType = SlotWinType.TrippleJoker;
+                multi = 30;
+            }
+            else
+            {
+                winType = SlotWinType.TrippleNormal;
+                multi = 10;
+            }
+        }
+        else if (a == 5 && (b == 5 || c == 5)
+                 || (b == 5 && c == 5))
+        {
+            winType = SlotWinType.DoubleJoker;
+            multi = 4;
+        }
+        else if (rolls.Any(x => x == 5))
+        {
+            winType = SlotWinType.SingleJoker;
+            multi = 1;
+        }
+
+        return new()
+        {
+            Won = bet * multi,
+            WinType = winType,
+            Multiplier = multi,
+            Rolls = rolls,
+        };
+    }
+*/

src/NadekoBot/_common/Gambling/Slot/SlotResult.cs

@@ -0,0 +1,9 @@
+namespace Nadeko.Econ.Gambling;
+
+public readonly struct SlotResult
+{
+    public decimal Multiplier { get; init; }
+    public byte[] Rolls { get; init; }
+    public decimal Won { get; init; }
+    public SlotWinType WinType { get; init; }
+}

src/NadekoBot/_common/Gambling/Wof/LuLaResult.cs

@@ -0,0 +1,9 @@
+namespace Nadeko.Econ.Gambling;
+
+public readonly struct LuLaResult
+{
+    public int Index { get; init; }
+    public decimal Multiplier { get; init; }
+    public decimal Won { get; init; }
+    public IReadOnlyList<decimal> Multipliers { get; init; }
+}

src/NadekoBot/_common/Gambling/Wof/WofGame.cs

@@ -0,0 +1,34 @@
+namespace Nadeko.Econ.Gambling;
+
+public sealed class LulaGame
+{
+    private static readonly IReadOnlyList<decimal> DEFAULT_MULTIPLIERS = new[] { 1.7M, 1.5M, 0.2M, 0.1M, 0.3M, 0.5M, 1.2M, 2.4M };
+    
+    private readonly IReadOnlyList<decimal> _multipliers;
+    private static readonly NadekoRandom _rng = new();
+
+    public LulaGame(IReadOnlyList<decimal> multipliers)
+    {
+        _multipliers = multipliers;
+    }
+
+    public LulaGame() : this(DEFAULT_MULTIPLIERS)
+    {
+    }
+
+    public LuLaResult Spin(long bet)
+    {
+        var result = _rng.Next(0, _multipliers.Count);
+
+        var multi = _multipliers[result];
+        var amount = bet * multi;
+
+        return new()
+        {
+            Index = result,
+            Multiplier = multi,
+            Won = amount,
+            Multipliers = _multipliers.ToArray(),
+        };
+    }
+}