예제 #1
0
파일: TestCases.cs 프로젝트: rosilio6/test
        private void SetUpInactiveGame()
        {
            Game.GameStatus = 1;

            //Creating turns for User1
            Flop f1 = new Flop();
            Flop f2 = new Flop();
            Flop f3 = new Flop();

            // User1 Hand
            LinkedList <Card> handPair = new LinkedList <Card>();

            handPair.AddLast(new Card(Value.Eight, Suit.Club));
            handPair.AddLast(new Card(Value.Ace, Suit.Spade));

            // User2 Hand
            LinkedList <Card> handPairTwo = new LinkedList <Card>();

            handPair.AddLast(new Card(Value.Two, Suit.Club));
            handPair.AddLast(new Card(Value.Seven, Suit.Spade));

            initFlop(f1, f2, f3);

            InitUser(f1, f2, f3, handPair, 1212, "User1");
            InitUser(f1, f2, f3, handPairTwo, 2323, "User2");
        }
예제 #2
0
        private bool UpdateFlop(IDatavObj obj)
        {
            Flop flop       = obj as Flop;
            var  existFlops = Flops.Where(p => p.Name() == flop.Name());

            if (existFlops.Any())
            {
                Flop existFlop = existFlops.First();
                if (existFlop.Same(flop))
                {
                    return(false);
                }
                else
                {
                    Logger.Log($"[Datav][{Name}]更新翻牌器:");
                    Logger.Log(flop.ToString());
                    Logger.Log($"[Datav][{Name}]--------------");
                    Flops.Remove(existFlop);
                    Flops.Add(flop);
                    return(true);
                }
            }
            else
            {
                Flops.Add(flop);
                return(true);
            }
        }
예제 #3
0
 public void PerformFlop(Deck deck)
 {
     deck.Discard();
     Flop.Add(deck.Draw());
     Flop.Add(deck.Draw());
     Flop.Add(deck.Draw());
 }
예제 #4
0
        public ActionResult <List <FlopReturnValue> > UpdateFlop(string datavName, string flopName, int startNumber, int variation, int changeInterval)
        {
            Flop            flop      = new Flop(flopName, datavName, startNumber, startNumber, variation, changeInterval);
            Flop            existFlop = Backend.Instance.Controller().GetFlop(datavName, flopName);
            FlopReturnValue ret       = new FlopReturnValue("", 0);

            if (existFlop == null)
            {
                bool succ = Backend.Instance.Controller().NewObj(datavName, flop);
                if (succ)
                {
                    ret.value = flop.CurrentNumber;
                }
            }
            else
            {
                if (flop.Same(existFlop))
                {
                    ret.value = existFlop.CurrentNumber;
                }
                else
                {
                    Backend.Instance.Controller().UpdateObj(datavName, flop);
                    ret.value = startNumber;
                }
            }
            List <FlopReturnValue> retlist = new List <FlopReturnValue>();

            retlist.Add(ret);
            return(retlist);
        }
예제 #5
0
        protected override void EnregistrerFlop(Flop evt)
        {
            _flop[0] = evt.Carte1;
            _flop[1] = evt.Carte2;
            _flop[2] = evt.Carte3;

            EcrireDetailPartie(evt.DateEvenement, _numDonne, "Flop", evt.Carte1.LibelleCarte() + "," + evt.Carte2.LibelleCarte() + "," + evt.Carte3.LibelleCarte(), evt.Pot.ToString(), PAS_D_INFOS);
        }
예제 #6
0
 private void TraiterEvtFlop(Flop evt)
 {
     _board[0] = evt.Carte1;
     _board[1] = evt.Carte2;
     _board[2] = evt.Carte3;
     _pot      = evt.Pot;
     LancerEvtMessageInfo(new MessageInfo(EtapeDonne.Flop, _board));
 }
예제 #7
0
 private void FlopUpdated(Flop obj)
 {
     Prepare(cards[0], obj.First);
     Prepare(cards[1], obj.Second);
     Prepare(cards[2], obj.Third);
     Prepare(cards[3], obj.Fourth);
     Prepare(cards[4], obj.Fiveth);
 }
예제 #8
0
파일: Seat.cs 프로젝트: HanNguyen-dev/P2
 public void NewRound()
 {
     Pocket.Clear();
     PlayerHand.HandCards.Clear();
     PlayerHand.HandValue = 0;
     Flop.Clear();
     Active    = true;
     RoundBid  = 0;
     HandValue = 0;
 }
예제 #9
0
파일: Game.cs 프로젝트: jagruar/poker
        private void EvaluateHands()
        {
            IEnumerable <Card> cards = Flop.Append(Turn).Append(River);

            foreach (var player in Players)
            {
                var combinedCards        = player.Cards.Concat(cards);
                IEnumerable <Hand> hands = combinedCards.DifferentCombinations(5).Select(x => new Hand(x));
                player.HandValue = hands.Max(x => x.Value);
            }
        }
예제 #10
0
파일: TestCases.cs 프로젝트: rosilio6/test
        private void InitUser(Flop f1, Flop f2, Flop f3, LinkedList <Card> handPair, int userMoney, String userName)
        {
            // Pack the Hand
            Hand h1 = new Hand(handPair);

            Turn turnOne   = new Turn(h1, f1, 425, userMoney);
            Turn turnTwo   = new Turn(h1, f2, 425, userMoney);
            Turn turnThree = new Turn(h1, f3, 425, userMoney);

            LinkedList <Turn> userTurns = new LinkedList <Turn>();

            userTurns.AddLast(turnOne);
            userTurns.AddLast(turnTwo);
            userTurns.AddLast(turnThree);

            //add to user his turns
            Game.GameHistory.Add(userName, userTurns);
        }
예제 #11
0
        private bool AddFlop(IDatavObj obj)
        {
            Flop flop       = obj as Flop;
            var  existFlops = Flops.Where(p => p.Name() == flop.Name());

            if (existFlops.Any())
            {
                return(false);
            }
            else
            {
                Logger.Log($"[Datav][{Name}]创建翻牌器:");
                Logger.Log(flop.ToString());
                Logger.Log($"[Datav][{Name}]--------------");
                Flops.Add(flop);
                return(true);
            }
        }
예제 #12
0
 /// <summary>
 /// Enregistrement du flop
 /// </summary>
 /// <param name="carte1"></param>
 /// <param name="carte2"></param>
 /// <param name="carte3"></param>
 /// <param name="pot"></param>
 internal void EnregistrerFlop(CartePoker carte1, CartePoker carte2, CartePoker carte3, int pot)
 {
     try
     {
         Flop enregFlop = new Flop();
         enregFlop.Carte1 = carte1;
         enregFlop.Carte2 = carte2;
         enregFlop.Carte3 = carte3;
         enregFlop.Pot    = pot;
         foreach (IStatistiques stat in _statistiques)
         {
             stat.Enregistrer(enregFlop);
         }
     }
     catch (Exception ex)
     {
         logServeur.Debug("Erreur lors d'EnregistrerFlop : " + ex.Message);
     }
 }
예제 #13
0
        private GameState GetCurrentGameState()
        {
            try
            {
                var state = new GameState()
                {
                    Players    = GetAllPlayers()?.ToArray(),
                    Flop       = Flop?.ToArray(),
                    Pot        = Pot,
                    PendingPot = PendingPot,
                    Round      = Round
                };

                return(state);
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
예제 #14
0
파일: TestCases.cs 프로젝트: rosilio6/test
        private void initFlop(Flop f1, Flop f2, Flop f3)
        {
            f1.Cards[0] = new Card(Value.Ace, Suit.Club);
            f1.Cards[1] = new Card(Value.Ace, Suit.Diamond);
            f1.Cards[2] = new Card(Value.Ace, Suit.Heart);
            f1.Cards[3] = null;
            f1.Cards[4] = null;


            f2.Cards[0] = new Card(Value.Ace, Suit.Club);
            f2.Cards[1] = new Card(Value.Ace, Suit.Diamond);
            f2.Cards[2] = new Card(Value.Ace, Suit.Heart);
            f2.Cards[3] = new Card(Value.King, Suit.Heart);
            f2.Cards[4] = null;

            f3.Cards[0] = new Card(Value.Ace, Suit.Club);
            f3.Cards[1] = new Card(Value.Ace, Suit.Diamond);
            f3.Cards[2] = new Card(Value.Ace, Suit.Heart);
            f3.Cards[3] = new Card(Value.King, Suit.Heart);
            f3.Cards[4] = new Card(Value.Two, Suit.Heart);
        }
 public static void OnFlop(object sender, FlopEventArgs e)
 {
     Flop?.Invoke(null, e);
 }
예제 #16
0
 protected virtual void EnregistrerFlop(Flop evt)
 {
 }
예제 #17
0
 public FlopTest()
 {
     this.Flop = new Flop();
 }
예제 #18
0
        public void EndRound()
        {
            int          PotTotal             = 0;
            int          NewPot               = 0;
            List <DSeat> PeopleWhoCanWinMoney = new List <DSeat>();
            List <DSeat> NewPotPeople         = new List <DSeat>();
            List <DSeat> MatchingHandValues   = new List <DSeat>();

            GetTurnOrder();
            foreach (DSeat seat in SeatsInTurnOrder)
            {
                if (seat.Occupied && seat.Active && seat.RoundBid > 0)
                {
                    PeopleWhoCanWinMoney.Add(seat);
                }
            }
            foreach (DSeat seat in SeatsInTurnOrder)
            {
                if (seat.Occupied)
                {
                    PotTotal += seat.RoundBid;
                }
            }
            if (PeopleWhoCanWinMoney.Count == 1)
            {
                PeopleWhoCanWinMoney[0].ChipTotal += PotTotal;
                MoveBlinds();
                Flop.Clear();
                return;
            }
            foreach (DSeat seat in PeopleWhoCanWinMoney)
            {
                seat.FindBestHand();
            }
            do
            {
                PeopleWhoCanWinMoney = PeopleWhoCanWinMoney.OrderByDescending(h => h.HandValue).ToList();
                if (PeopleWhoCanWinMoney[0].HandValue > PeopleWhoCanWinMoney[1].HandValue)
                {
                    NewPotPeople.Clear();
                    for (int i = 1; i < PeopleWhoCanWinMoney.Count; i++)
                    {
                        if (PeopleWhoCanWinMoney[i].RoundBid > PeopleWhoCanWinMoney[0].RoundBid)
                        {
                            NewPotPeople.Add(PeopleWhoCanWinMoney[i]);
                        }
                    }
                    if (NewPotPeople.Count == 0)
                    {
                        PeopleWhoCanWinMoney[0].ChipTotal += PotTotal;
                        MoveBlinds();
                        Flop.Clear();
                        return;
                    }
                    else
                    {
                        foreach (DSeat seat in NewPotPeople)
                        {
                            NewPot        += seat.RoundBid - PeopleWhoCanWinMoney[0].RoundBid;
                            seat.RoundBid -= PeopleWhoCanWinMoney[0].RoundBid;
                        }
                        PotTotal -= NewPot;
                        PeopleWhoCanWinMoney[0].ChipTotal += PotTotal;
                        PeopleWhoCanWinMoney = new List <DSeat>(NewPotPeople);
                        PotTotal             = NewPot;
                        NewPot = 0;
                    }
                }
                else
                {
                    //get list of people who have matching hand values
                    MatchingHandValues.Clear();
                    MatchingHandValues.Add(PeopleWhoCanWinMoney[0]);
                    for (int i = 1; i < PeopleWhoCanWinMoney.Count; i++)
                    {
                        if (PeopleWhoCanWinMoney[i].HandValue == PeopleWhoCanWinMoney[0].HandValue)
                        {
                            MatchingHandValues.Add(PeopleWhoCanWinMoney[i]);
                        }
                    }
                    //run through the cards one by one to see if someone has a high value
                    for (int i = 0; i < 5; i++)
                    {
                        foreach (DSeat seat in MatchingHandValues)
                        {
                            seat.HandValue += seat.PlayerHand.HandCards[i].Value;
                        }
                        MatchingHandValues = MatchingHandValues.OrderByDescending(h => h.HandValue).ToList();
                        if (MatchingHandValues[0].HandValue > MatchingHandValues[1].HandValue)
                        {
                            break;
                        }
                    }
                    //if someone has the highest value
                    if (MatchingHandValues[0].HandValue > MatchingHandValues[1].HandValue)
                    {
                        PeopleWhoCanWinMoney = PeopleWhoCanWinMoney.OrderByDescending(h => h.HandValue).ToList();
                        NewPotPeople.Clear();
                        for (int i = 1; i < PeopleWhoCanWinMoney.Count; i++)
                        {
                            if (PeopleWhoCanWinMoney[i].RoundBid > PeopleWhoCanWinMoney[0].RoundBid)
                            {
                                NewPotPeople.Add(PeopleWhoCanWinMoney[i]);
                            }
                        }
                        if (NewPotPeople.Count == 0)
                        {
                            PeopleWhoCanWinMoney[0].ChipTotal += PotTotal;
                        }
                        else
                        {
                            foreach (DSeat seat in NewPotPeople)
                            {
                                NewPot        += seat.RoundBid - PeopleWhoCanWinMoney[0].RoundBid;
                                seat.RoundBid -= PeopleWhoCanWinMoney[0].RoundBid;
                            }
                            PotTotal -= NewPot;
                            PeopleWhoCanWinMoney[0].ChipTotal += PotTotal;
                            PeopleWhoCanWinMoney = new List <DSeat>(NewPotPeople);
                            PotTotal             = NewPot;
                            NewPot = 0;
                            foreach (DSeat seat in PeopleWhoCanWinMoney)
                            {
                                seat.FindBestHand();
                            }
                        }
                    }
                    else
                    {
                        // may have matching hand levels but different pot levels\
                        MatchingHandValues = MatchingHandValues.OrderByDescending(h => h.HandValue).ToList();
                        List <DSeat> StillMatching = new List <DSeat>();
                        StillMatching.Add(MatchingHandValues[0]);

                        for (int i = 1; i < MatchingHandValues.Count; i++)
                        {
                            if (MatchingHandValues[i].HandValue == StillMatching[0].HandValue)
                            {
                                StillMatching.Add(MatchingHandValues[0]);
                            }
                        }
                        StillMatching = StillMatching.OrderBy(h => h.RoundBid).ToList();

                        NewPotPeople.Clear();
                        for (int i = 1; i < PeopleWhoCanWinMoney.Count; i++)
                        {
                            if (PeopleWhoCanWinMoney[i].RoundBid > StillMatching[0].RoundBid)
                            {
                                NewPotPeople.Add(PeopleWhoCanWinMoney[i]);
                            }
                        }
                        if (NewPotPeople.Count == 0)
                        {
                            // divide pot among still matching
                            if (PotTotal % StillMatching.Count != 0)
                            {
                                StillMatching[0].ChipTotal += 1;
                            }
                            foreach (DSeat seat in StillMatching)
                            {
                                seat.ChipTotal += PotTotal / StillMatching.Count;
                            }
                        }
                        else
                        {
                            foreach (DSeat seat in NewPotPeople)
                            {
                                NewPot        += seat.RoundBid - StillMatching[0].RoundBid;
                                seat.RoundBid -= StillMatching[0].RoundBid;
                            }
                            PotTotal -= NewPot;
                            foreach (DSeat seat in StillMatching)
                            {
                                seat.ChipTotal += PotTotal / StillMatching.Count;
                            }
                            PeopleWhoCanWinMoney = new List <DSeat>(NewPotPeople);
                            PotTotal             = NewPot;
                            NewPot = 0;
                        }
                    }
                }
            } while (NewPotPeople.Count > 0);
            // NEED TO ADD MOVING THE SMALL BLIND BIG BLIND
            MoveBlinds();
            Flop.Clear();
        }
예제 #19
0
        public static int BetRequest(GameState gameState)
        {
            try
            {
                LogicResult result = null;
                if (gameState.CommunityCards.Count == 0)
                {
                    result = Preflop.Result(gameState);
                }
                if (gameState.CommunityCards.Count == 3)
                {
                    result = Flop.Result(gameState);
                }
                if (gameState.CommunityCards.Count == 4)
                {
                    result = Turn.Result(gameState);
                }
                if (gameState.CommunityCards.Count == 5)
                {
                    result = River.Result(gameState);
                }

                if (result == null)
                {
                    Console.WriteLine("RESULT IS NULL");
                    return(0);
                }

                if (gameState.IsAllin())
                {
                    if (result.CanRespondToAllIn)
                    {
                        return(int.MaxValue);
                    }
                    else
                    {
                        return(0);
                    }
                }

                if (result.RaiseOdds > 0)
                {
                    var raiseBase = Math.Max(gameState.Pot - gameState.Me().Bet, gameState.MinimumRaise);
                    return(gameState.Me().Bet + (int)Math.Round(raiseBase * result.RaiseOdds));
                }
                if (result.CallOdds > 0)
                {
                    var toCall = gameState.CurrentBuyIn - gameState.Me().Bet;
                    var odds   = toCall / (gameState.Pot + 1);
                    if (result.CallOdds > odds)
                    {
                        return(toCall);
                    }
                }
                return(0);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
                return(0);
            }
        }
예제 #20
0
 public static LogicResult Result(GameState state)
 {
     return(Flop.Result(state));
 }
예제 #21
0
        IEnumerator Start()
        {
            var cards = new Card[52];

            for (var cardIndex = 0; cardIndex < cards.Length; cardIndex++)
            {
                cards[cardIndex] = new Card
                {
                    State = Card.States.None,
                    Suit  = cardIndex / 13,
                    Value = cardIndex % 13
                };
            }

            Deck = new Stack <Card>(cards.OrderBy(x => Random.value));

            Entity flop = Manager.CreateEntity(typeof(Flop), typeof(Bid));

            Entity local    = Entity.Null;
            Entity oponent1 = Entity.Null;
            Entity oponent2 = Entity.Null;


            for (int i = 0; i < 9; i++)
            {
                var sit = Manager.CreateEntity();
                AddOrSet(sit, new Sit {
                    Id = i
                });

                if (i == 0)
                {
                    local = sit;
                }

                if (i == 4)
                {
                    oponent1 = sit;
                }

                if (i == 5)
                {
                    oponent2 = sit;
                }
            }

            yield return(new WaitForSeconds(2f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(local, new Player {
                Id = 50
            });
            AddOrSet(local, new Bank {
                Value = 10000
            });


            yield return(new WaitForSeconds(2f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(oponent1, new Player {
                Id = 60
            });
            AddOrSet(oponent1, new Bank {
                Value = 10000
            });

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(oponent2, new Player {
                Id = 70
            });
            AddOrSet(oponent2, new Bank {
                Value = 10000
            });

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            AddOrSet(oponent1, new Bid()
            {
                Value = 5
            });
            AddOrSet(oponent2, new Bid()
            {
                Value = 10
            });

            AddOrSet(oponent1, new Bank()
            {
                Value = 10000 - 5
            });
            AddOrSet(oponent2, new Bank()
            {
                Value = 10000 - 10
            });


            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            var localCards     = default(Cards);
            var opponent1Cards = default(Cards);
            var opponent2Cards = default(Cards);

            localCards.Right = RandomCard();

            AddOrSet(local, localCards);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            opponent1Cards.Right = RandomCard(Card.States.Close);
            AddOrSet(oponent1, opponent1Cards);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            opponent2Cards.Right = RandomCard(Card.States.Close);
            AddOrSet(oponent2, opponent2Cards);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            localCards.Left = RandomCard();
            AddOrSet(local, localCards);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            opponent1Cards.Left = RandomCard(Card.States.Close);
            AddOrSet(oponent1, opponent1Cards);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            opponent2Cards.Left = RandomCard(Card.States.Close);
            AddOrSet(oponent2, opponent2Cards);

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            AddOrSet(local, new Bid()
            {
                Value = 100
            });
            AddOrSet(local, new Bank()
            {
                Value = 10000 - 100
            });
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(oponent1, new Bid()
            {
                Value = 250
            });
            AddOrSet(local, new Bank()
            {
                Value = 10000 - 250
            });
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            Manager.RemoveComponent <Cards>(oponent2);
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(local, new Bid()
            {
                Value = 250
            });
            AddOrSet(local, new Bank()
            {
                Value = 10000 - 250
            });
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            var flop1 = new Flop
            {
                First  = RandomCard(),
                Second = RandomCard(),
                Third  = RandomCard()
            };

            AddOrSet(flop, flop1);
            AddOrSet(local, default(Bid));
            AddOrSet(oponent1, default(Bid));
            AddOrSet(oponent2, default(Bid));
            AddOrSet(flop, new Bid()
            {
                Value = 510
            });

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());


            flop1.Fourth = RandomCard();
            AddOrSet(flop, flop1);

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(oponent1, new Bid()
            {
                Value = 1500
            });
            AddOrSet(oponent1, new Bank()
            {
                Value = 10000 - 250 - 1500
            });

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(local, new Bid()
            {
                Value = 1500
            });
            AddOrSet(local, new Bank()
            {
                Value = 10000 - 250 - 1500
            });

            yield return(new WaitForSeconds(2.1f));

            yield return(new WaitForEndOfFrame());


            AddOrSet(local, default(Bid));
            AddOrSet(oponent1, default(Bid));
            AddOrSet(flop, new Bid()
            {
                Value = 510 + 3000
            });
            flop1.Fiveth = RandomCard();
            AddOrSet(flop, flop1);


            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(oponent1, new Bid()
            {
                Value = 5000
            });
            AddOrSet(oponent1, new Bank()
            {
                Value = 10000 - 250 - 1500 - 5000
            });
            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(local, new Bid()
            {
                Value = 5000
            });
            AddOrSet(local, new Bank()
            {
                Value = 10000 - 250 - 1500 - 5000
            });

            yield return(new WaitForSeconds(2.5f));

            yield return(new WaitForEndOfFrame());

            AddOrSet(local, default(Bid));
            AddOrSet(oponent1, default(Bid));
            AddOrSet(flop, new Bid()
            {
                Value = 510 + 3000 + 10000
            });


            AddOrSet(oponent1, new Cards
            {
                Left  = RandomCard(),
                Right = RandomCard()
            });

            yield return(new WaitForSeconds(2f));

            yield return(new WaitForEndOfFrame());


            AddOrSet(flop, default(Bid));
            AddOrSet(oponent1, default(Bid));
            AddOrSet(oponent2, default(Bid));
            AddOrSet(local, default(Bid));

            Manager.RemoveComponent <Cards>(local);
            Manager.RemoveComponent <Cards>(oponent1);
            Manager.RemoveComponent <Flop>(flop);

            AddOrSet(local, new Bank {
                Value = 10000 - 250 - 1500 - 5000 + 510 + 3000 + 10000
            });
        }