Exemple #1
0
        static void Main(string[] args)
        {
            //딜러
            Dealer dealer = new Dealer();

            //보드
            Board board = new Board();

            //스코럴
            Scorer scorer = new Scorer();

            //플레이어
            //List는 동적배열
            List <Player> players = new List <Player>();

            players.Add(new Player(0));
            players.Add(new Player(1));

            // 둘 중 한 명이 올인 날 때까지..
            while (CanGoRound(players))
            {
                // 라운드 진행

                // 딜러가 카드를 섞는다.
                dealer.Shuffle();

                // 판돈 내기
                for (int i = 0; i < players.Count; i++)
                {
                    players[i].Money -= 100;
                    board.Money      += 100;
                }

                // 카드 나눠주기(각 플레이어에게 2장씩 준다)
                for (int i = 0; i < players.Count; i++)
                {
                    players[i].cards.Clear();
                    for (int j = 0; j < 2; j++)
                    {
                        Card card = dealer.GetCard();
                        players[i].TakeCard(card);
                    }
                }

                // 승자를 찾는다.
                Player winner = scorer.GetWinner(players[0], players[1]);

                // 무승부면 루프의 처음으로 다시 돌아가서 실행.
                if (winner == null)
                {
                    continue;
                }

                // 판돈을 승자에게 준다.
                winner.Money += board.Money;
                // 보드는 금액을 0으로 초기화.
                board.Money = 0;

                // 플레리어가 가진 카드와 소지금, 승자를 출력한다.
                PrintRoundResult(players, winner);
            } // end of while()
        }     //end of main()
Exemple #2
0
        public static int RunRound(List <Player> players, int winnerNo)
        {
            // 각 선수가 이전 라운드에서 받은 카드를 클리어한다.
            foreach (Player player in players)
            {
                player.PrepareRound();
            }

            // 이전 라운드의 승자는 이번 라운드의 베팅 배수를 결정한다.
            // 단, 1라운드일 경우 선을 결정하여 베팅 배수를 결정한다.
            string inputText = "";
            int    input     = 0;
            Random random    = new Random();

            if (winnerNo == 0) // 사용자가 이기면
            {
                Console.WriteLine($"P[{winnerNo}] 는 이번 라운드의 배수를 선택하세요. (1: 1배, 2: 2배, 3: 4배, 4: 8배)");
                inputText = Console.ReadLine();
                input     = int.Parse(inputText);
                MultipleType multipleType = (MultipleType)input;
                Console.WriteLine($"P[{winnerNo}]는 {(int)multipleType}배를 선택하여 이번 판의 판돈이 {(int)multipleType}배 증가하였습니다.");
            }
            else
            {   // 컴퓨터가 승자일 때, 컴퓨터는 결과에 상관없이 판돈의 두 배를 올린다.
                // Console.WriteLine($"P[{winnerNo}] 는 2배만을 선택");
                input = random.Next(1, 4);
                MultipleType multipleType = (MultipleType)input;
                Console.WriteLine($"P[{winnerNo}]는 {(int)multipleType}배를 선택하여 이번 판의 판돈이 {(int)multipleType}배 증가하였습니다.");
                // input = 2;
            }

            // 선수들이 학교를 간다
            int totalBetMoney = 0;

            foreach (Player player in players)
            {
                player.Money  -= BetMoney * input;
                totalBetMoney += BetMoney * input;
            }

            // 딜러가 각 선수들에게 2장씩 카드를 돌린다
            Dealer dealer = new Dealer();

            foreach (Player player in players)
            {
                for (int i = 0; i < 2; i++)
                {
                    player.AddCard(dealer.Draw());
                }
            }


            if (winnerNo == 0)
            {
                Player p = players[winnerNo];
                p.CalculateScore();
                Console.WriteLine($"P{winnerNo} ({p[0]}, {p[1]}) => {p.Score}");


                // 사용자의 카드의 점수가 5점 이하일 경우, 300원을 추가로 내고 새로운 카드를 뽑는다.
                if (p.Score <= 5)
                {
                    Console.WriteLine("300원을 추가로 지불하고 첫번째 카드를 바꾸시겠습니까? (y/n)");

                    if (Console.ReadLine().Equals("y"))
                    {
                        p.ChangeCard(dealer.Draw());
                        p.CalculateScore();
                        p.Money -= 300;
                        Console.WriteLine($"P{winnerNo}의 바꾼 카드: ({p[0]}, {p[1]}) => {p.Score}");
                        PrintMoney(p);
                    }
                    else
                    {
                        Console.WriteLine("카드를 변경하지 않고 게임을 진행합니다.");
                    }
                }
                Console.WriteLine("콜 유형를 선택하세요. (1: 콜(기본), 2: 베팅(+100원 * 배수), 3: 다이(포기, 1/2만 돌려받음))");
                inputText = Console.ReadLine();
                input     = int.Parse(inputText);
                callType  = (CallType)input; // 숫자로 입력받은 콜 타입을 콜타입 타입으로 형변환한다.
                Console.WriteLine($"{callType}을 선택하셨습니다.");
            }
            else
            {   // 컴퓨터가 이기면 콜타입을 결정한다.
                callType = DecideCallType(players, winnerNo);
                Console.WriteLine($"P[{winnerNo}]가 {callType}을 선택하였습니다.");
            }


            if (callType == CallType.Die)
            {
                Player p = players[winnerNo];
                p.Money       += BetMoney * input / 2;
                totalBetMoney -= BetMoney * input / 2;
            }
            //if ( callType == CallType.Die)
            //{
            //    foreach (Player player in players)
            //    {
            //        if(player.Index == winnerNo)
            //        {
            //            player.Money += BetMoney * input / 2;
            //            totalBetMoney -= BetMoney * input / 2;
            //        }
            //    }

            //    foreach (Player player in players)
            //    {
            //        if (player.Index != winnerNo)
            //        {
            //            player.Money += totalBetMoney / 2;
            //        }
            //    }


            //}
            else if (callType == CallType.Betting)
            {
                foreach (Player player in players)
                {
                    player.Money  -= BetMoney * input;
                    totalBetMoney += BetMoney * input;
                }
            }

            // 각 선수들의 족보를 계산하고 출력한다.
            for (int i = 0; i < players.Count; i++)
            {
                Player p = players[i];

                p.CalculateScore();
                Console.WriteLine($"P{i} ({p[0]}, {p[1]}) => {p.Score}");
            }

            // 승자와 패자를 가린다.
            // 승자에게 모든 베팅 금액을 준다.
            if (FindWinner(players).Count >= 2) // 승자가 두명이면
            {
                int winner0 = FindWinner(players)[0];
                int winner1 = FindWinner(players)[1];

                players[winner0].Money += totalBetMoney / 2; // 전체 베팅머니를 반씩 나눠가진다.
                players[winner1].Money += totalBetMoney / 2;

                winnerNo = AdvancedRule.DecideOrder(players);
                return(winnerNo);
            }
            else
            {
                winnerNo = FindWinner(players)[0];
                players[winnerNo].Money += totalBetMoney;
                return(winnerNo);
            }
        }
Exemple #3
0
        public static int RunRound(List <Player> players, int winnerNo)
        {
            // 각 선수가 이전 라운드에서 받은 카드를 클리어한다.
            foreach (Player player in players)
            {
                player.PrepareRound();
            }

            // 이전 라운드의 승자는 이번 라운드의 베팅 배수를 결정한다.
            // 단, 1라운드일 경우 선을 결정하여 베팅 배수를 결정한다.
            string inputText = "";
            int    input     = 0;

            if (winnerNo == 0)
            {
                Console.WriteLine($"P[{winnerNo}] 는 이번 라운드의 배수를 선택하세요. (1: 1배, 2: 2배, 4: 4배, 8: 8배)");
                inputText = Console.ReadLine();
                input     = int.Parse(inputText);
            }
            else
            {
                Console.WriteLine($"P[{winnerNo}] 는 2배만을 선택");
                input = 2;
            }

            // 선수들이 학교를 간다
            int totalBetMoney = 0;

            foreach (Player player in players)
            {
                player.Money  -= BetMoney * input;
                totalBetMoney += BetMoney * input;
            }

            // 딜러가 각 선수들에게 2장씩 카드를 돌린다
            Dealer dealer = new Dealer();

            foreach (Player player in players)
            {
                for (int i = 0; i < 2; i++)
                {
                    player.AddCard(dealer.Draw());
                }
            }


            if (winnerNo == 0)
            {
                Player p = players[winnerNo];
                p.CalculateScore();
                Console.WriteLine($"P{winnerNo} ({p[0]}, {p[1]}) => {p.Score}");
                Console.WriteLine("콜 유형를 선택하세요. (1: 콜(기본), 2: 베팅(+100원 * 배수), 3: 다이(포기, 1/2만 돌려받음))");
                inputText = Console.ReadLine();
                input     = int.Parse(inputText);
                callType  = (CallType)input;
            }
            else
            {
                callType = DecideCallType(players, winnerNo);
                Console.WriteLine($"P[{winnerNo}]는 {callType}을 선택");
            }


            if (callType == CallType.Die)
            {
                Player p = players[winnerNo];
                p.Money       += BetMoney * input / 2;
                totalBetMoney -= BetMoney * input / 2;
            }
            //if ( callType == CallType.Die)
            //{
            //    foreach (Player player in players)
            //    {
            //        if(player.Index == winnerNo)
            //        {
            //            player.Money += BetMoney * input / 2;
            //            totalBetMoney -= BetMoney * input / 2;
            //        }
            //    }

            //    foreach (Player player in players)
            //    {
            //        if (player.Index != winnerNo)
            //        {
            //            player.Money += totalBetMoney / 2;
            //        }
            //    }


            //}
            else if (callType == CallType.Betting)
            {
                foreach (Player player in players)
                {
                    player.Money  -= BetMoney * input;
                    totalBetMoney += BetMoney * input;
                }
            }

            // 각 선수들의 족보를 계산하고 출력한다.
            for (int i = 0; i < players.Count; i++)
            {
                Player p = players[i];

                p.CalculateScore();
                Console.WriteLine($"P{i} ({p[0]}, {p[1]}) => {p.Score}");
            }

            // 승자와 패자를 가린다.
            // 승자에게 모든 베팅 금액을 준다.
            if (FindWinner(players).Count >= 2)
            {
                players[FindWinner(players)[0]].Money += totalBetMoney / 2;
                players[FindWinner(players)[1]].Money += totalBetMoney / 2;

                winnerNo = AdvancedRule.DecideOrder(players);
                return(winnerNo);
            }
            else
            {
                winnerNo = FindWinner(players)[0];
                players[winnerNo].Money += totalBetMoney;
                return(winnerNo);
            }
        }
Exemple #4
0
        public const int BettingMoney = 100; // 배팅금

        static void Main(string[] args)
        {
            #region 섯다 족보
            IEnumerable <Genealogy> Gen = new Genealogy[]
            {
                new Genealogy {
                    Name = "삼팔광땡", Score = 100
                },
                new Genealogy {
                    Name = "광땡", Score = 90
                },
                new Genealogy {
                    Name = "멍텅구리 구사", Score = 80
                },
                new Genealogy {
                    Name = "일땡", Score = 61
                },
                new Genealogy {
                    Name = "이땡", Score = 62
                },
                new Genealogy {
                    Name = "삼땡", Score = 63
                },
                new Genealogy {
                    Name = "사땡", Score = 64
                },
                new Genealogy {
                    Name = "오땡", Score = 65
                },
                new Genealogy {
                    Name = "육땡", Score = 66
                },
                new Genealogy {
                    Name = "칠땡", Score = 67
                },
                new Genealogy {
                    Name = "팔땡", Score = 68
                },
                new Genealogy {
                    Name = "구땡", Score = 69
                },
                new Genealogy {
                    Name = "장땡", Score = 70
                },
                new Genealogy {
                    Name = "구사", Score = 50
                },
                new Genealogy {
                    Name = "알리", Score = 15
                },
                new Genealogy {
                    Name = "독사", Score = 14
                },
                new Genealogy {
                    Name = "구삥", Score = 13
                },
                new Genealogy {
                    Name = "장삥", Score = 12
                },
                new Genealogy {
                    Name = "장사", Score = 11
                },
                new Genealogy {
                    Name = "세륙", Score = 10
                },                                       // 십끗 => 4, 6 만
                new Genealogy {
                    Name = "갑오", Score = 9
                },                                       // 구끗
                new Genealogy {
                    Name = "팔끗", Score = 8
                },
                new Genealogy {
                    Name = "칠끗", Score = 7
                },
                new Genealogy {
                    Name = "육끗", Score = 6
                },
                new Genealogy {
                    Name = "오끗", Score = 5
                },
                new Genealogy {
                    Name = "사끗", Score = 4
                },
                new Genealogy {
                    Name = "삼끗", Score = 3
                },
                new Genealogy {
                    Name = "이끗", Score = 2
                },
                new Genealogy {
                    Name = "일끗", Score = 1
                },
                new Genealogy {
                    Name = "망통", Score = 0
                },
                new Genealogy {
                    Name = "암행어사", Score = 1
                },
                new Genealogy {
                    Name = "땡잡이", Score = 0
                }                                       // 3, 7 만
            };
            #endregion


            var spgt = from g in Gen where g.Score == 100 select g; // 삼팔광땡
            var gt   = from g in Gen where g.Score == 90 select g;  // 광땡
            var mtgr = from g in Gen where g.Score == 80 select g;  // 멍텅구리 구사

            foreach (Genealogy gen in spgt)
            {
                Console.WriteLine(gen.Name);
            }
            foreach (Genealogy gen in gt)
            {
                Console.WriteLine(gen.Name);
            }



            Console.WriteLine("┌────────────────┐");
            Console.WriteLine("│\t   룰을 선택하세요.       │");
            Console.WriteLine("│\t      1. Basic\t          │");
            Console.WriteLine("│\t      2. Simple\t          │");
            Console.WriteLine("└────────────────┘");
            Console.Write(" ☞ ");
            int      input    = int.Parse(Console.ReadLine());
            RuleType ruleType = (RuleType)input;
            Console.WriteLine();

            #region Memo1
            // unit test => 테스트 코드들을 모아두는??

            //Player p = new Player();
            //p.GoToShcool(); // 배팅하기. 아래 코드보다 이게 나음
            //p.Money -= 100; // 됨
            //p.Cards = new List<Card>(); // 카드 생성? 이 안됨
            //p.Cards.Add(new Card()); // 카드 추가는 됨
            #endregion

            #region  레이어 2명
            List <Player> players = new List <Player>();
            for (int i = 0; i < 2; i++)
            {
                if (ruleType == RuleType.Basic)
                {
                    players.Add(new BasicPlayer());
                }
                else
                {
                    players.Add(new SimplePlayer());
                }
            } // 각각의 타입에 따른 객체를 오버라이딩하여 생성
            #endregion

            #region Memo - var
            //// C#에서의 var은 타입을 유추할 수 있을 때 사용함.
            //int i = 1;
            //var i2 = 1;
            //string s = "aa";
            //var s2 = "bb";

            //Dictionary<int, List<List<string>>> list = new Dictionary<int, List<List<string>>>();
            //var list2 = new Dictionary<int, List<List<string>>>();
            #endregion

            #region  레이어들의 종잣돈 지급
            int ChanceNumber = 1;

            foreach (var player in players)
            {
                player.Money     = SeedMoney; // 플레이어들에게 500원씩 지급
                player.OneChance = ChanceNumber;
            }
            #endregion

            int round         = 1; // 초기 라운드
            int rematchNumber = 1; // 배팅금 배율

            #region 게임 시작
            while (true)
            {
                #region 올인시 게임 종료
                if (IsAnyoneAllIn(players)) //한명이 올인하면 게임 종료
                {
                    Console.WriteLine("┌────────────────┐");
                    Console.WriteLine("│\t    ~ 이제 그만 ~\t  │");
                    Console.WriteLine("└────────────────┘");
                    Console.WriteLine();
                    break;
                }
                #endregion

                Console.WriteLine(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                Console.WriteLine($"\t     [Round {round++}]");

                // 딜러는 매 라운드마다 하나씩 만들어짐
                Dealer dealer = new Dealer();

                #region 학교 출석 (배팅)
                foreach (var player in players)
                {
                    player.Money -= (BettingMoney * rematchNumber);

                    if (player.Money < 0)
                    {
                        Console.WriteLine("┌────────────────┐");
                        Console.WriteLine("│  ♨ 배팅금액 부족 경기불가 ♨  │");
                        Console.WriteLine("└────────────────┘");
                        return;
                    }
                    else
                    {
                        dealer.PutMoney(BettingMoney * rematchNumber);
                    }
                }
                #endregion

                #region 카드배분
                foreach (var player in players)
                {
                    player.Cards.Clear();

                    for (int i = 0; i < 2; i++)
                    {
                        player.Cards.Add(dealer.DrawCard());
                    }

                    Console.WriteLine(player.GetCardText());
                }
                #endregion

                #region 경기 (일반적 / 재경기)

                JudgeRematch(Rematch(players)); // 멍텅구리 구사, 구사, 무승부

                if (Rematch(players) == 80 || Rematch(players) == 50 ||
                    Rematch(players) == 40)
                {
                    int money = dealer.GetMoney() / 2;

                    for (int i = 0; i < 2; i++)
                    {
                        players[i].Money += money;
                    }

                    rematchNumber = rematchNumber * 2; // 재경기 시 배팅금 배율 2배
                    continue;
                }
                else  //일반적 상황
                {
                    // 승자 찾기
                    Player winner = FindWinner(players);

                    // 승자에게 상금 주가
                    winner.Money += dealer.GetMoney();

                    rematchNumber = 1; // 배팅금 배율 초기화

                    // 각 플레이어들의 돈 출력
                    for (int i = 0; i < 2; i++)
                    {
                        Console.Write($"     Player {i + 1}'s Money : ");
                        Console.WriteLine("₩ " + players[i].Money);
                    }

                    Console.WriteLine(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                    Console.WriteLine();
                }
                #endregion

                PayBackOrGoToThePolice(players); // 기사회생, 경찰서
            }
            #endregion
        }
Exemple #5
0
        static void Main(string[] args)
        {
            Console.WriteLine("룰 타입을 선택하세요. (1:Basic, 2:Develop)");
            int      input    = int.Parse(Console.ReadLine());
            RuleType ruleType = (RuleType)input;

            Printline();
            List <Player> players = new List <Player>();

            if (ruleType == RuleType.Basic)
            {
                players.Add(new RealPlayer());
                players.Add(new ComputerPlayer());
            }

            else
            {
                for (int i = 0; i < 2; i++)
                {
                    players.Add(new RealPlayer());
                }
            }


            foreach (var player in players)
            {
                player.Money = SeedMoney;
            }

            int round = 1;

            while (true)
            {
                Console.WriteLine();
                Console.WriteLine();
                Console.WriteLine();

                // 한명이 오링이면 게임 종료
                if (IsAnyoneOring(players))
                {
                    break;
                }

                Console.WriteLine($"[Round {round}]을 진행합니다.");
                Printline();
                round++;

                Dealer dealer = new Dealer();

                // 학교 출석
                foreach (var player in players)
                {
                    player.Money -= BettingMoney;
                    dealer.PutMoney(BettingMoney);
                }

                // 카드 돌리기
                foreach (var player in players)
                {
                    player.Cards.Clear();
                    dealer.Cards.Clear();


                    for (int i = 0; i < 2; i++)
                    {
                        player.Cards.Add(dealer.DrawCard());
                    }

                    Console.WriteLine(player.GetCardText());
                }
                Printline();
                Console.WriteLine("게임을 계속하시겠습니까? (1. 콜   2. 다이)");
                Console.WriteLine("[콜] 하면 50원 추가 배팅 후 딜러 패 공개,");
                Console.WriteLine("[다이]하면 모든 패 공개 후 패배로 처리.");

                int sel = int.Parse(Console.ReadLine());

                bool surren = Surren(sel);

                //딜러 패 뽑기
                dealer.Cards.Add(dealer.DrawCard());

                //딜러가 뽑은 패 각자 덱으로 삽입
                foreach (var player in players)
                {
                    player.Cards.Add(dealer.DealerCard());
                }

                Printline();
                //딜러가 뽑은 패 공개
                Console.WriteLine(dealer.GetCardTextDealer());
                Printline();

                Console.WriteLine(players[0].GetCardText());

                PrintMyGokbo(players);

                Printline();

                if (!surren)
                {
                    foreach (var player in players)
                    {
                        player.Money -= CallBettingMoney;
                        dealer.PutMoney(CallBettingMoney);
                    }

                    Console.WriteLine("게임을 계속하시겠습니까? (1. 콜   2. 다이)");
                    Console.WriteLine("[콜]하면 모든 패 공개,");
                    Console.WriteLine("[다이]하면 패배로 처리.");

                    int finalsel = int.Parse(Console.ReadLine());

                    surren = Surren(finalsel);

                    Printline();
                    //무승부 찾기
                    if (Regame(players))
                    {
                        continue;
                    }
                }



                // 승자 찾기
                Player winner = FindWinner(players, surren);

                // 승자에게 상금 주기
                winner.Money += dealer.GetMoney();


                // 각 플레이어의 돈 출력
                Printline();
                foreach (var player in players)
                {
                    Console.Write(player.Money + "\t");
                }


                Console.WriteLine();
                Console.WriteLine("다음 라운드 진행을 위해 아무 숫자를 입력해 주세요.");
                int nextRound = int.Parse(Console.ReadLine());

                Printline();
            }
        }