BJ | C# Online Compiler

BJ by Papaicha

using System;
using System.Linq;
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System.Globalization;
					
public class Program
{
	public static void Main()
	{
		CardValue card = new();
		card.SetHiLo("A");
		
		var oldGame = new GGPoker();
		oldGame.Args = new GGPokerArgs()
		{
			Dealer = new GGPokerDealerArgs()
			{
				Cards = new List<GGPokerCards>() {
					{ new GGPokerCards() { Value = "AC" } },
					{ new GGPokerCards() { Value = "AH" } }
				}
			},
			Seats = new Dictionary<string, GGPokerPlayerArgs>()
			{
				{ "4", new GGPokerPlayerArgs() 
					{
						Data = new GGPokerPlayer()
						{
							Cards = new List<GGPokerCards>() {
								{ new GGPokerCards() { Value = "2C" } },
								{ new GGPokerCards() { Value = "Hello" } }
							}
						}
					}
				},
				{ "3", new GGPokerPlayerArgs() 
					{
						Data = new GGPokerPlayer()
						{
							Cards = new List<GGPokerCards>() {
								{ new GGPokerCards() { Value = "8C" } },
								{ new GGPokerCards() { Value = "4H" } },
								{ new GGPokerCards() { Value = "5H" } }
							}
						}
					}
				}
			}
		};
		
		var game = new GGPoker();
		game.Args = new GGPokerArgs()
		{
			Dealer = new GGPokerDealerArgs()
			{
				Cards = new List<GGPokerCards>() {
					{ new GGPokerCards() { Value = "AC" } },
					{ new GGPokerCards() { Value = "AH" } },
					{ new GGPokerCards() { Value = "8H" } },
				}
			},
			Seats = new Dictionary<string, GGPokerPlayerArgs>()
			{
				{ "4", new GGPokerPlayerArgs() 
					{
						Data = new GGPokerPlayer()
						{
							Cards = new List<GGPokerCards>() {
								{ new GGPokerCards() { Value = "2C" } },
								{ new GGPokerCards() { Value = "8C" } },
							}
						}
					}
				},
				{ "3", new GGPokerPlayerArgs() 
					{
						Data = new GGPokerPlayer()
						{
							Cards = new List<GGPokerCards>() {
								{ new GGPokerCards() { Value = "8C" } },
								{ new GGPokerCards() { Value = "4H" } },
								{ new GGPokerCards() { Value = "5H" } },
							}
						}
					}
				}
			}
		};
		
		Compare compare = new(game, oldGame);
		if (compare.IsEqual() == false)
		{
			var lst = compare.GetCardsDifference().ToList();	
			lst.ForEach(l => Console.WriteLine(l));
		}
		
		Calculate calc = new();
		
		//Console.WriteLine(calc.RunningCount(game));
		
	}
}

public class Compare
    {
        private GGPoker _game;
        private GGPoker? _storedGame;

        public Compare(GGPoker game, GGPoker? storedGame)
        {
            _game = game;
            _storedGame = StoredGame(storedGame);
        }

        private GGPoker? StoredGame(GGPoker? storedGame)
        {
            return storedGame;
        }

        public bool IsEqual()
        {
            Cards cards = new(_game);
            var newCards = cards.GetCards();

            if (_storedGame == null) return false;

            Cards storedCards = new(_storedGame);
            var oldCards = storedCards.GetCards();

            return Enumerable.SequenceEqual(oldCards, newCards);
        }

        public IEnumerable<string>? GetCardsDifference()
        {
            if (_storedGame == null) return null;

            var lstDealer = GetDifference(_game.Args.Dealer.Cards, _storedGame.Args.Dealer.Cards);

            List<string> lstPlayers = new();

            for (int i = 0; i < _game.Args.Seats.Count; i++) 
            {				
				var lstTmpPlayers = GetDifference(_game.Args.Seats.ToList()[i].Value.Data.Cards, _storedGame.Args.Seats.ToList()[i].Value.Data.Cards);				
				lstPlayers = lstPlayers.Concat(lstTmpPlayers).ToList();
            }

            return lstDealer.Concat(lstPlayers);
        }
	
	

        public List<string> GetDifference(List<GGPokerCards> cards, List<GGPokerCards> oldCards)
        {
            List<string> lst = new();

            for (int i = 0; i < cards.Count; i++)
            {
                if (i < oldCards.Count)
                {
                    if (cards[i].Value != oldCards[i].Value)
                    {
                        lst.Add(cards[i].Value);
                    }
                }
                else
                {
                    lst.Add(cards[i].Value);
                }
            }

            return lst;
        }
		
    }

public class Cards
    {
        private GGPoker Game;
        public Cards(GGPoker game) => Game = game;

        public IEnumerable<string> GetCards()
        {
            List<string> cards = new();

            Game.Args.Dealer.Cards.ForEach(c => cards.Add(c.Value));
            Game.Args.Seats.ToList().ForEach(s => s.Value.Data.Cards.ForEach((c) => cards.Add(c.Value)));

            return cards;
        }
    }

public class Calculate
    {
        /// <summary>
        /// The number of cards by deck
        /// </summary>
        public int CardsByDeck = 52;
        public int CardsBySuit = 4;
        /// <summary>
        /// The number of Decks in the table
        /// </summary>
        public int Deck = 6;
        /// <summary>
        /// Store the current number of decks
        /// </summary>
        private double numberOfDecks { get; set; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="numberOfCardsExposed"></param>
        /// <returns></returns>
        public double NumberOfDecks(int numberOfCardsExposed)
        {
            int total = CardsByDeck * Deck;

            int remainingCards = total - numberOfCardsExposed;
            double numberOfDecks = (remainingCards * Deck) / total;

            return this.numberOfDecks = Math.Round(numberOfDecks, 2);
        }

        public int? RunningCount(GGPoker ggPoker)
        {
            var cardValue = new CardValue();

            int? total = 0;

            ggPoker.Args.Dealer.Cards.ForEach(p => total += cardValue.SetHiLo(cardValue.SanitizeCard(p.Value)));

            if (ggPoker.Args.Seats is not null)
            {
                ggPoker.Args.Seats.ToList().ForEach(p =>
                {
                    if (p.Value.Data.Cards is not null)
                        p.Value.Data.Cards.ForEach(c => total += cardValue.SetHiLo(cardValue.SanitizeCard(c.Value)));
                });
            }

            return total;     
        }
	
        public int? RunningCount(List<string> ggPoker)
        {
            int? total = 0;
            var card = new CardValue();

            ggPoker.ForEach(g => total += card.SetHiLo(card.SanitizeCard(g)));

            return total;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="runningCount"></param>
        /// <see cref="https://betandbeat.com/blackjack/strategy/card-counting/true-count/"/>
        /// <returns></returns>
        public double TrueCount(int runningCount)
        {
            double trueCount = runningCount / numberOfDecks;
            return Math.Round(trueCount, 2);
        }
    }

public class CardValue
    {       
        /// <summary>
        /// Segregate the cards into three groups by number, then assign that group a value
        /// </summary>
        protected readonly Dictionary<int, string[]> _cards = new()
        {
            { 1, new string[] { "2", "3", "4", "5", "6" } },
            { 0, new string[] { "7", "8", "9" } },
            { -1, new string[] { "T", "J", "Q", "K", "A" } },
        };

        /// <summary>
        /// If is a valid string, remove the Card Suit from the string, only leaving the Card Value. 
        /// Else a null value it's returned
        /// </summary>
        /// <param name="card"></param>
        /// <returns></returns>
        public string? SanitizeCard(string card)
        {
            char[] chars = card.ToCharArray();

            if (chars.Length != 2)
                return null;

            return chars[0].ToString();
        }

        /// <summary>
        /// Assign a card its 'Hi Lo' value
        /// </summary>
        /// <param name="card"></param>
        /// <returns></returns>
        public int? SetHiLo(string? card)
        {
			if (card is null) return 0;
			
            int? hiLoValue = this._cards.Where(p => p.Value.Contains(card)).ToList().FirstOrDefault().Key;

            if (hiLoValue is null)
                return null;

            return hiLoValue;
        }
    }

public partial class GGPoker
    {
        /// <summary>
        /// The transaction Id
        /// </summary>
        [JsonProperty("id")]
        public string Id { get; set; }
        /// <summary>
        /// Type of game and version number
        /// </summary>
        [JsonProperty("type")]
        public string Type { get; set; }
        /// <summary>
        /// A table data collection
        /// </summary>
        [JsonProperty("args")]
        public GGPokerArgs Args { get; set; }
        /// <summary>
        /// The time of the WebSocket transaction in Unix Timestamp
        /// </summary>
        [JsonProperty("time")]
        public long Time { get; set; }
    }

    public class GGPokerArgs
    {
        /// <summary>
        /// The Id of the current game
        /// </summary>
        [JsonProperty("gameId")]
        public string GameId { get; set; }
        /// <summary>
        /// The Dealer information
        /// </summary>
        [JsonProperty("dealer")]
        public GGPokerDealerArgs Dealer { get; set; }

        [JsonProperty("seats")]
        public Dictionary<string, GGPokerPlayerArgs> Seats { get; set; }
        [JsonProperty("dealingOrder")]
        public object[] DealingOrder { get; set; }

        [JsonProperty("dealingSequence")]
        public object[] DealingSequence { get; set; }
    }

    public class GGPokerDealerArgs
    {
        [JsonProperty("cards")]
        public List<GGPokerCards> Cards { get; set; }
        /// <summary>
        /// The total of the sum of the values
        /// </summary>
        [JsonProperty("score")]
        public int Score { get; set; }
        [JsonProperty("dealNoOfCards")]
        public int DealNoOfCards { get; set; }
    }

    public class GGPokerPlayerArgs
    {
        [JsonProperty("first")]
        public GGPokerPlayer Data { get; set; }
    }

    public class GGPokerPlayer
    {
        [JsonProperty("cards")]
        public List<GGPokerCards> Cards { get; set; }
        /// <summary>
        /// The total of the sum of the values
        /// </summary>
        [JsonProperty("score")]
        public int Score { get; set; }
        [JsonProperty("state")]
        public string State { get; set; }

        [JsonProperty("confirmedDecisions", NullValueHandling = NullValueHandling.Ignore)]
        public List<GGPokerPlayerDecisions> ConfirmedDecisions { get; set; }

        [JsonProperty("result", NullValueHandling = NullValueHandling.Ignore)]
        public string Result { get; set; }
    }

    public class GGPokerPlayerDecisions
    {
        [JsonProperty("decision")]
        public string Decision { get; set; }

        [JsonProperty("t")]
        public long T { get; set; }

        [JsonProperty("preDecision")]
        public bool PreDecision { get; set; }

        [JsonProperty("validation")]
        public bool Validation { get; set; }

        [JsonProperty("decisionId", NullValueHandling = NullValueHandling.Ignore)]
        public string DecisionId { get; set; }
    }

    public class GGPokerCards
    {
        /// <summary>
        /// The card value expressed by its value and suit. Like 8H, TC
        /// </summary>
        [JsonProperty("value")]
        public string Value { get; set; }
        [JsonProperty("deck")]
        public int Deck { get; set; }
        [JsonProperty("t")]
        public long T { get; set; }
    }

    public partial class GGPoker
    {
        public static GGPoker FromJson(string json) => JsonConvert.DeserializeObject<GGPoker>(json, Converter.Settings);
    }

    public static class Serialize
    {
        public static string ToJson(this GGPoker self) => JsonConvert.SerializeObject(self, Converter.Settings);
    }

    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }

​x
 
using System;
using System.Linq;
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System.Globalization;
                    
public class Program
{
    public static void Main()
    {
        CardValue card = new();
        card.SetHiLo("A");
        
        var oldGame = new GGPoker();
        oldGame.Args = new GGPokerArgs()
        {
            Dealer = new GGPokerDealerArgs()
            {
                Cards = new List<GGPokerCards>() {
                    { new GGPokerCards() { Value = "AC" } },
                    { new GGPokerCards() { Value = "AH" } }
                }
            },
            Seats = new Dictionary<string, GGPokerPlayerArgs>()
            {
                { "4", new GGPokerPlayerArgs() 
                    {
                        Data = new GGPokerPlayer()
                        {
                            Cards = new List<GGPokerCards>() {
                                { new GGPokerCards() { Value = "2C" } },
                                { new GGPokerCards() { Value = "Hello" } }
                            }
                        }
                    }
                },
                { "3", new GGPokerPlayerArgs() 
                    {
                        Data = new GGPokerPlayer()
                        {
                            Cards = new List<GGPokerCards>() {
                                { new GGPokerCards() { Value = "8C" } },
                                { new GGPokerCards() { Value = "4H" } },
                                { new GGPokerCards() { Value = "5H" } }
                            }
                        }
                    }
                }
            }
        };
        
        var game = new GGPoker();
        game.Args = new GGPokerArgs()
        {
            Dealer = new GGPokerDealerArgs()
            {
                Cards = new List<GGPokerCards>() {
                    { new GGPokerCards() { Value = "AC" } },
                    { new GGPokerCards() { Value = "AH" } },
                    { new GGPokerCards() { Value = "8H" } },
                }
            },
            Seats = new Dictionary<string, GGPokerPlayerArgs>()
            {
                { "4", new GGPokerPlayerArgs() 
                    {
                        Data = new GGPokerPlayer()
                        {
                            Cards = new List<GGPokerCards>() {
                                { new GGPokerCards() { Value = "2C" } },
                                { new GGPokerCards() { Value = "8C" } },
                            }
                        }
                    }
                },
                { "3", new GGPokerPlayerArgs() 
                    {
                        Data = new GGPokerPlayer()
                        {
                            Cards = new List<GGPokerCards>() {
                                { new GGPokerCards() { Value = "8C" } },
                                { new GGPokerCards() { Value = "4H" } },
                                { new GGPokerCards() { Value = "5H" } },
                            }
                        }
                    }
                }
            }
        };
        
        Compare compare = new(game, oldGame);
        if (compare.IsEqual() == false)
        {
            var lst = compare.GetCardsDifference().ToList();    
            lst.ForEach(l => Console.WriteLine(l));
        }
        
        Calculate calc = new();
        
        //Console.WriteLine(calc.RunningCount(game));
        
    }
}
​
public class Compare
    {
        private GGPoker _game;
        private GGPoker? _storedGame;
​
        public Compare(GGPoker game, GGPoker? storedGame)
        {
            _game = game;
            _storedGame = StoredGame(storedGame);
        }
​
        private GGPoker? StoredGame(GGPoker? storedGame)
        {
            return storedGame;
        }
​
        public bool IsEqual()
        {
            Cards cards = new(_game);
            var newCards = cards.GetCards();
​
            if (_storedGame == null) return false;
​
            Cards storedCards = new(_storedGame);
            var oldCards = storedCards.GetCards();
​
            return Enumerable.SequenceEqual(oldCards, newCards);
        }
​
        public IEnumerable<string>? GetCardsDifference()
        {
            if (_storedGame == null) return null;
​
            var lstDealer = GetDifference(_game.Args.Dealer.Cards, _storedGame.Args.Dealer.Cards);
​
            List<string> lstPlayers = new();
​
            for (int i = 0; i < _game.Args.Seats.Count; i++) 
            {               
                var lstTmpPlayers = GetDifference(_game.Args.Seats.ToList()[i].Value.Data.Cards, _storedGame.Args.Seats.ToList()[i].Value.Data.Cards);              
                lstPlayers = lstPlayers.Concat(lstTmpPlayers).ToList();
            }
​
            return lstDealer.Concat(lstPlayers);
        }
    
    
​
        public List<string> GetDifference(List<GGPokerCards> cards, List<GGPokerCards> oldCards)
        {
            List<string> lst = new();
​
            for (int i = 0; i < cards.Count; i++)
            {
                if (i < oldCards.Count)
                {
                    if (cards[i].Value != oldCards[i].Value)
                    {
                        lst.Add(cards[i].Value);
                    }
                }
                else
                {
                    lst.Add(cards[i].Value);
                }
            }
​
            return lst;
        }
        
    }
​
public class Cards
    {
        private GGPoker Game;
        public Cards(GGPoker game) => Game = game;
​
        public IEnumerable<string> GetCards()
        {
            List<string> cards = new();
​
            Game.Args.Dealer.Cards.ForEach(c => cards.Add(c.Value));
            Game.Args.Seats.ToList().ForEach(s => s.Value.Data.Cards.ForEach((c) => cards.Add(c.Value)));
​
            return cards;
        }
    }
​
public class Calculate
    {
        /// <summary>
        /// The number of cards by deck
        /// </summary>
        public int CardsByDeck = 52;
        public int CardsBySuit = 4;
        /// <summary>
        /// The number of Decks in the table
        /// </summary>
        public int Deck = 6;
        /// <summary>
        /// Store the current number of decks
        /// </summary>
        private double numberOfDecks { get; set; }
​
        /// <summary>
        /// 
        /// </summary>
        /// <param name="numberOfCardsExposed"></param>
        /// <returns></returns>
        public double NumberOfDecks(int numberOfCardsExposed)
        {
            int total = CardsByDeck * Deck;
​
            int remainingCards = total - numberOfCardsExposed;
            double numberOfDecks = (remainingCards * Deck) / total;
​
            return this.numberOfDecks = Math.Round(numberOfDecks, 2);
        }
​
        public int? RunningCount(GGPoker ggPoker)
        {
            var cardValue = new CardValue();
​
            int? total = 0;
​
            ggPoker.Args.Dealer.Cards.ForEach(p => total += cardValue.SetHiLo(cardValue.SanitizeCard(p.Value)));
​
            if (ggPoker.Args.Seats is not null)
            {
                ggPoker.Args.Seats.ToList().ForEach(p =>
                {
                    if (p.Value.Data.Cards is not null)
                        p.Value.Data.Cards.ForEach(c => total += cardValue.SetHiLo(cardValue.SanitizeCard(c.Value)));
                });
            }
​
            return total;     
        }
    
        public int? RunningCount(List<string> ggPoker)
        {
            int? total = 0;
            var card = new CardValue();
​
            ggPoker.ForEach(g => total += card.SetHiLo(card.SanitizeCard(g)));
​
            return total;
        }
​
        /// <summary>
        /// 
        /// </summary>
        /// <param name="runningCount"></param>
        /// <see cref="https://betandbeat.com/blackjack/strategy/card-counting/true-count/"/>
        /// <returns></returns>
        public double TrueCount(int runningCount)
        {
            double trueCount = runningCount / numberOfDecks;
            return Math.Round(trueCount, 2);
        }
    }
​
public class CardValue
    {       
        /// <summary>
        /// Segregate the cards into three groups by number, then assign that group a value
        /// </summary>
        protected readonly Dictionary<int, string[]> _cards = new()
        {
            { 1, new string[] { "2", "3", "4", "5", "6" } },
            { 0, new string[] { "7", "8", "9" } },
            { -1, new string[] { "T", "J", "Q", "K", "A" } },
        };
​
        /// <summary>
        /// If is a valid string, remove the Card Suit from the string, only leaving the Card Value. 
        /// Else a null value it's returned
        /// </summary>
        /// <param name="card"></param>
        /// <returns></returns>
        public string? SanitizeCard(string card)
        {
            char[] chars = card.ToCharArray();
​
            if (chars.Length != 2)
                return null;
​
            return chars[0].ToString();
        }
​
        /// <summary>
        /// Assign a card its 'Hi Lo' value
        /// </summary>
        /// <param name="card"></param>
        /// <returns></returns>
        public int? SetHiLo(string? card)
        {
            if (card is null) return 0;
            
            int? hiLoValue = this._cards.Where(p => p.Value.Contains(card)).ToList().FirstOrDefault().Key;
​
            if (hiLoValue is null)
                return null;
​
            return hiLoValue;
        }
    }
​
public partial class GGPoker
    {
        /// <summary>
        /// The transaction Id
        /// </summary>
        [JsonProperty("id")]
        public string Id { get; set; }
        /// <summary>
        /// Type of game and version number
        /// </summary>
        [JsonProperty("type")]
        public string Type { get; set; }
        /// <summary>
        /// A table data collection
        /// </summary>
        [JsonProperty("args")]
        public GGPokerArgs Args { get; set; }
        /// <summary>
        /// The time of the WebSocket transaction in Unix Timestamp
        /// </summary>
        [JsonProperty("time")]
        public long Time { get; set; }
    }
​
    public class GGPokerArgs
    {
        /// <summary>
        /// The Id of the current game
        /// </summary>
        [JsonProperty("gameId")]
        public string GameId { get; set; }
        /// <summary>
        /// The Dealer information
        /// </summary>
        [JsonProperty("dealer")]
        public GGPokerDealerArgs Dealer { get; set; }
​
        [JsonProperty("seats")]
        public Dictionary<string, GGPokerPlayerArgs> Seats { get; set; }
        [JsonProperty("dealingOrder")]
        public object[] DealingOrder { get; set; }
​
        [JsonProperty("dealingSequence")]
        public object[] DealingSequence { get; set; }
    }
​
    public class GGPokerDealerArgs
    {
        [JsonProperty("cards")]
        public List<GGPokerCards> Cards { get; set; }
        /// <summary>
        /// The total of the sum of the values
        /// </summary>
        [JsonProperty("score")]
        public int Score { get; set; }
        [JsonProperty("dealNoOfCards")]
        public int DealNoOfCards { get; set; }
    }
​
    public class GGPokerPlayerArgs
    {
        [JsonProperty("first")]
        public GGPokerPlayer Data { get; set; }
    }
​
    public class GGPokerPlayer
    {
        [JsonProperty("cards")]
        public List<GGPokerCards> Cards { get; set; }
        /// <summary>
        /// The total of the sum of the values
        /// </summary>
        [JsonProperty("score")]
        public int Score { get; set; }
        [JsonProperty("state")]
        public string State { get; set; }
​
        [JsonProperty("confirmedDecisions", NullValueHandling = NullValueHandling.Ignore)]
        public List<GGPokerPlayerDecisions> ConfirmedDecisions { get; set; }
​
        [JsonProperty("result", NullValueHandling = NullValueHandling.Ignore)]
        public string Result { get; set; }
    }
​
    public class GGPokerPlayerDecisions
    {
        [JsonProperty("decision")]
        public string Decision { get; set; }
​
        [JsonProperty("t")]
        public long T { get; set; }
​
        [JsonProperty("preDecision")]
        public bool PreDecision { get; set; }
​
        [JsonProperty("validation")]
        public bool Validation { get; set; }
​
        [JsonProperty("decisionId", NullValueHandling = NullValueHandling.Ignore)]
        public string DecisionId { get; set; }
    }
​
    public class GGPokerCards
    {
        /// <summary>
        /// The card value expressed by its value and suit. Like 8H, TC
        /// </summary>
        [JsonProperty("value")]
        public string Value { get; set; }
        [JsonProperty("deck")]
        public int Deck { get; set; }
        [JsonProperty("t")]
        public long T { get; set; }
    }
​
    public partial class GGPoker
    {
        public static GGPoker FromJson(string json) => JsonConvert.DeserializeObject<GGPoker>(json, Converter.Settings);
    }
​
    public static class Serialize
    {
        public static string ToJson(this GGPoker self) => JsonConvert.SerializeObject(self, Converter.Settings);
    }
​
    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }

View IL Code