Example #1
0
        //힌트 제공
        private void btnHint_Click(object sender, EventArgs e)
        {
            if (!gameEnd)
            {
                //힌트를 줄 수 있는 상황이라면 힌트 주기
                if (judge.CanGiveHint())
                {
                    score.GiveHintPenalty();
                    _state = GameState.Hint;
                }
                else //아닐 경우
                {
                    //딜러가 카드를 줄 수 있다면 새 카드 받기 권유
                    if (dealer.CanPlayCard())
                    {
                        _state = GameState.GetNewCard;
                    }
                    else
                    {
                        for (int i = 1; i <= board.boardLines.Count; i++)
                        {
                            if (board.LineIsEmpty(i))
                            {
                                _state = GameState.NoMoreHint;
                            }
                            else
                            {
                                _state = GameState.GameOver;
                                break;
                            }
                        }
                    }
                }

                if (score.IsGameOver())
                {
                    _state  = GameState.GameOver;
                    gameEnd = true;
                    DisableGameBoard();
                }

                //보드 상태 확인(print)
                PrintBoard(board, score, dealer);
            }
        }
Example #2
0
        //보드의 상태 프린트
        private void PrintBoard(Board board, Score score, Dealer dealer)
        {
            //보드에 놓인 카드들 이미지 변환
            for (int i = 1; i <= Board.MAX_LINES; i++)
            {
                List <Card>       cardList    = board.boardLines[i - 1];
                List <PictureBox> pictureList = graphicCard.curCards[i - 1];

                //각 줄마다 카드 갯수에 변경이 생겼을 경우 그림도 추가, 삭제
                int diff = pictureList.Count - cardList.Count;
                if (diff != 0)
                {
                    if (diff > 0)
                    {
                        graphicCard.RemovePictureBox(board, i, diff);
                    }
                    else
                    {
                        graphicCard.MakePictureBox(board, i, diff * -1);
                    }
                }

                //한 줄당 출력해줄 갯수는 최대 13개로 제한
                int amount = cardList.Count > MAX_PICTURE_AMOUNT ? MAX_PICTURE_AMOUNT : cardList.Count;

                //픽쳐박스가 있는 위치에 들어갈만한 카드로부터 이미지를 찾아옴
                List <PictureBox> pictureBoxes = graphicCard.GetPictureBoxes(board, i, amount);
                for (int j = 0; j < pictureBoxes.Count; j++)
                {
                    pictureBoxes[j].Image = graphicCard.FindImage(cardList[cardList.Count - amount + j]);
                }
            }

            lblRemainCardSet.Text = $" 남은 카드 세트 : {(dealer.cards.Count / Dealer.MAX_CARD_NUMBER) - score.CardSetCount}";
            lblScore.Text         = $" 점수 : {score.Scores}";

            string state = "";

            switch (_state)
            {
            case GameState.DealerIsEmpty:
                state = "더이상 카드를 줄 수 없습니다";
                break;

            case GameState.BoardLineIsEmpty:
                state = "카드가 없는 라인이 있습니다";
                break;

            case GameState.GetNewCard:
                state = "새 카드를 받아오세요";
                break;

            case GameState.NoMoreHint:
                state = "힌트를 줄 수 없습니다";
                break;

            case GameState.CantTransferCards:
                state = "카드를 교환할 수 없습니다";
                break;

            case GameState.WrongInput:
                state = "잘못된 입력입니다";
                break;

            case GameState.TooManyCards:
                state = "그만큼 보낼 수 없습니다";
                break;

            case GameState.Win:
                state = "You Win!";
                break;

            case GameState.GameOver:
                state = "You Lose ㅠㅠ";
                break;
befault:
                state = "";
                break;
            }
            lblState.Text = state;

            if (_state == GameState.Hint)
            {
                txtSendLine.Text = board.hintLines[0].ToString();
                txtRecvLine.Text = board.hintLines[1].ToString();
                txtAmount.Text   = board.GetCardChainAmountFromLine(board.hintLines[0]).ToString();
            }
            else
            {
                txtAmount.Text   = "";
                txtSendLine.Text = "";
                txtRecvLine.Text = "";
            }

            if (!dealer.CanPlayCard())
            {
                pbxDealer.Visible = false;
            }

            _state = GameState.None;
        }
Example #3
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            player = players[dealer.GetCurrentPlayer()];

            if (isChangeAbility)
            {
                str = textBox.Text;
                if (int.TryParse(str, out num))
                {
                    num = Int32.Parse(str);
                    if (num <= (int)Card.Pattern.Joker)
                    {
                        dealer.ChangePattern((Card.Pattern)(num - 1));

                        isChangeAbility  = false;
                        lblQuestion.Text = "놓을 카드 번호를 입력해주세요.";
                        board.GetFieldCard().SpecialAbility(dealer);
                        dealer.ResetPlayCount();
                        GoToNextTurn();
                    }
                    else
                    {
                        MessageBox.Show("잘못된 입력입니다.");
                    }
                }
                else
                {
                    MessageBox.Show("숫자만 입력해주세요.");
                }
            }
            else
            {
                str = textBox.Text;
                if (int.TryParse(str, out num))
                {
                    if (num <= player.GetCardAmount())
                    {
                        if (dealer.CanPlayCard(player.GetCard(num)))
                        {
                            //카드 개수가 0개인지 확인
                            if (!GameIsEnd(players))
                            {
                                //처음 필드에 올려지는 카드는 능력을 발휘하지 않음
                                if (isInitialPrint)
                                {
                                    isInitialPrint = false;
                                }

                                //플레이어의 카드를 보드의 필드카드로 보냄
                                Card card = player.PlayCard(num);
                                SetCardToField(card, board, dealer);

                                //문양을 바꾸는 능력은 사용자의 입력을 미리 받아둬야함
                                if (IsChangeAbilityCard(card))
                                {
                                    lblQuestion.Text = "어떤 문양으로 변경?  1:♠  2:♣  3:◆  4:♥";
                                    isChangeAbility  = true;
                                }
                                else
                                {
                                    dealer.ResetPlayCount();
                                    //카드의 스페셜 능력 발동, 딜러를 건내줌
                                    card.SpecialAbility(dealer);
                                }

                                textBox.Clear();

                                if (GameIsEnd(players))
                                {
                                    GameEnd(players);
                                }

                                if (dealer.GetPlayCount() == 0)
                                {
                                    GoToNextTurn();
                                }
                                else
                                {
                                    DrawBoard();
                                }
                            }
                        }
                        else
                        {
                            MessageBox.Show("낼 수 없는 카드입니다.");
                            //낼 수 없는 카드인데도 턴이 넘겨지는 버그
                        }
                    }
                    else
                    {
                        MessageBox.Show("잘못된 입력입니다.");
                    }
                }
                else
                {
                    MessageBox.Show("숫자만 입력해주세요.");
                }
            }
        }
Example #4
0
        static void Main(string[] args)
        {
            Console.WriteLine("스파이더 게임 시작");

            Dealer dealer = new Dealer();
            Score  score  = new Score();
            Board  board  = new Board(dealer);
            Judge  judge  = new Judge(board, dealer);


            //게임 난이도 선택
            int difficulty = -1;

            while (true)
            {
                Console.Write("게임 난이도를 선택해주세요. (1: 보통 / 2: 어려움 / 3: 매우 어려움) ");
                try
                {
                    difficulty = int.Parse(Console.ReadLine());
                }
                catch (Exception e)
                {
                    Console.WriteLine("잘못된 입력입니다.");
                    continue;
                }

                if (difficulty >= 1 && difficulty <= 3)
                {
                    break;
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }

            switch (difficulty)
            {
            case 1: dealer.SetDifficulty(Difficulty.Normal); break;

            case 2: dealer.SetDifficulty(Difficulty.Hard); break;

            case 3: dealer.SetDifficulty(Difficulty.VerryHard); break;
            }


            //난이도에 따라 딜러가 셔플
            dealer.Shuffle();
            //셔플 후 딜러가 보드에 카드 배분
            board.InitBoard();


            int select   = -1;
            int sendLine = -1;
            int recvLine = -1;
            int amount   = -1;

            //보드에 카드가 남아있는 동안
            while (!judge.BoardIsEmpty() || !score.IsGameOver())
            {
                //보드 상태 확인(print)
                PrintBoard(board, score, dealer);
                //카드를 옮길 지, 새로 받을 지 결정
                while (true)
                {
                    Console.Write("나의 행동은? (1:카드 옮기기 / 2:새카드 받기 / 0:힌트) ");
                    try
                    {
                        select = int.Parse(Console.ReadLine());
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("잘못된 입력입니다.");
                        continue;
                    }

                    if (select >= 0 && select <= 2)
                    {
                        break;
                    }
                    else
                    {
                        Console.WriteLine("잘못된 입력입니다.");
                    }
                }

                //카드 옮기기일 경우
                if (select == 1)
                {
                    // 옮길 카드 줄, 양을 선택.
                    while (true)
                    {
                        Console.Write("옮기고 싶은 카드가 속한 라인을 선택하세요 (1~10 / 0:취소) ");
                        try
                        {
                            sendLine = int.Parse(Console.ReadLine());
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("잘못된 입력입니다.");
                            continue;
                        }

                        if (sendLine >= 0 && sendLine <= 10)
                        {
                            if (sendLine == 0 || !board.LineIsEmpty(sendLine))
                            {
                                break;
                            }
                            else
                            {
                                Console.WriteLine("이 라인에는 카드가 없습니다.");
                            }
                        }
                        else
                        {
                            Console.WriteLine("잘못된 입력입니다.");
                        }
                    }
                    //카드 옮기기 선택 취소
                    if (sendLine == 0)
                    {
                        continue;
                    }


                    //양의 경우 연속된 만큼만 가능하게 한다.
                    amount = board.GetCardChainAmountFromLine(sendLine);
                    while (true)
                    {
                        Console.Write($"몇 개의 카드를 옮기시겠습니까? (최대 {amount}장 / 0:취소) ");
                        try
                        {
                            select = int.Parse(Console.ReadLine());
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("잘못된 입력입니다.");
                            continue;
                        }

                        if (select >= 0 && select <= amount)
                        {
                            break;
                        }
                        else
                        {
                            Console.WriteLine("그만큼 옮길 수 없습니다.");
                        }
                    }
                    if (select == 0)
                    {
                        continue;
                    }


                    //옮길 위치 선택
                    while (true)
                    {
                        Console.Write("선택한 카드를 옮길 라인을 선택하세요 (1~10 / 0:취소) ");
                        try
                        {
                            recvLine = int.Parse(Console.ReadLine());
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("잘못된 입력입니다.");
                            continue;
                        }

                        //동일 라인으로 이동 불가
                        if (recvLine == sendLine)
                        {
                            Console.WriteLine("동일한 라인입니다. 다시 선택해주세요.");
                        }
                        else if (recvLine >= 0 && recvLine <= 10)
                        {
                            //받을 라인의 카드와 내가 보낼 카드가 연속될 수 있는가 확인
                            if (recvLine == 0 || judge.CanConveyCard(sendLine, select, recvLine))
                            {
                                break;
                            }
                            else
                            {
                                Console.WriteLine("이 라인으로는 옮길 수 없습니다.");
                            }
                        }
                        else
                        {
                            Console.WriteLine("잘못된 입력입니다.");
                        }
                    }
                    if (recvLine == 0)
                    {
                        continue;
                    }

                    //카드 옮기기
                    board.ConveyCardLineToLine(sendLine, select, recvLine);

                    //옮긴 후 움직임 수 증가 및 스코어 1 감소
                    score.GiveMovePenalty();
                    //카드 한 세트가 완성되면
                    if (judge.LineHasCardSet(recvLine))
                    {
                        board.RemoveOneCardSet(recvLine);
                        score.GiveOneCardSetScore();
                    }
                }
                //새로 받을 경우
                else if (select == 2)
                {
                    //딜러에게 카드가 없음
                    if (!dealer.CanPlayCard())
                    {
                        _state = GameState.DealerIsEmpty;
                    }
                    //보드의 모든 줄 중 어느것도 비지 않음
                    else if (!board.LinesAreNotEmpty())
                    {
                        _state = GameState.BoardLineIsEmpty;
                    }
                    else
                    {
                        //보드의 모든 줄에 카드 열 장씩 배부
                        board.ConveyCardToAllLine();
                    }
                }
                //힌트를 줘야하는 경우
                else
                {
                    //힌트를 줄 수 있는 상황이라면 힌트 주기
                    if (judge.CanGiveHint())
                    {
                        score.GiveHintPenalty();
                        _state = GameState.Hint;
                    }
                    else //아닐 경우
                    {
                        //딜러가 카드를 줄 수 있다면 새 카드 받기 권유
                        if (dealer.CanPlayCard())
                        {
                            _state = GameState.GetNewCard;
                        }
                        else
                        {
                            //힌트를 줄 수 없다면 게임오버
                            for (int i = 1; i <= board.boardLines.Count; i++)
                            {
                                if (board.LineIsEmpty(i))
                                {
                                    _state = GameState.NoMoreHint;
                                }
                                else
                                {
                                    _state = GameState.GameOver;
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            //게임 상태 프린트
            PrintBoard(board, score, dealer);
            //게임이 끝나면 점수 표시
            PrintResult(score);
        }
Example #5
0
        static void Main(string[] args)
        {
            //플레이하는 인원 수와 인원 수 당 제시할 카드 수 지정
            int  playersNumber    = 2;
            int  playingCardCount = 7;
            bool isPlayCountEnd   = false;

            //클래스들 선언
            Dealer        dealer  = new Dealer();
            Board         board   = new Board();
            List <Player> players = new List <Player>();

            //지정된 플레이어 수만큼 생성 후 리스트에 추가
            for (int i = 0; i < playersNumber; i++)
            {
                Player player = new Player(i);
                players.Add(player);
            }

            //먼저 시작할 플레이어 결정
            dealer.SetCurrentPlayer(0);

            //보드에서 카드 셔플
            board.SetCard();

            //플레이어들에게 지정한 만큼의 카드 배분
            for (int i = 0; i < playersNumber; i++)
            {
                for (int j = 0; j < playingCardCount; j++)
                {
                    SendCardToPlayer(board, players[i]);
                }
            }

            //필드에 하나 카드를 올려놓음. 이 카드를 시작으로 게임을 진행
            Card firstCard = board.GetBoardCard();

            SetCardToField(firstCard, board, dealer);


            String str = "";
            int    num = 0;

            //게임은 한 명이 파산하거나 카드 갯수가 0개가 될 때까지 계속된다.
            while (!GameIsEnd(players))
            {
                //시작하면 플레이어 한 명이 한 턴을 시작한다.
                Player player = players[dealer.GetCurrentPlayer()];

                //반복가능 횟수만큼 플레이 가능(특수카드 능력에 대비)
                for (int i = 0; i < dealer.GetPlayCount(); i++)
                {
                    isPlayCountEnd = false;

                    //화면을 보여줌
                    PrintBoard(board, dealer, players, player);

                    //반복가능 횟수 한 번을 썼으면(카드를 내던가 받던가 다 했으면)
                    while (!isPlayCountEnd)
                    {
                        //가진 카드 중 몇 번째 카드를 선택할 건지 선택지를 주고 플레이어가 선택
                        System.Console.WriteLine("몇 번째 카드를 선택? (카드 받기 : 0)");
                        str = System.Console.ReadLine();
                        try
                        {
                            num = Int32.Parse(str);
                        }
                        catch (FormatException e)
                        {
                            System.Console.WriteLine(e.Message);
                            continue;
                        }
                        if (num > player.GetCardAmount())
                        {
                            System.Console.WriteLine("잘못된 입력입니다.");
                            continue;
                        }

                        //새 카드를 뽑는 경우
                        if (num == 0)
                        {
                            //플레이어가 카드를 새로 받음
                            if (dealer.GetDamage() > 0)
                            {
                                for (int j = 1; j <= dealer.GetDamage(); j++)
                                {
                                    SendCardToPlayer(board, player);
                                }

                                dealer.ResetDamage();
                            }
                            else
                            {
                                SendCardToPlayer(board, player);
                            }

                            //카드 수가 초과할 경우를 대비해 확인
                            if (GameIsEnd(players))
                            {
                                break;
                            }
                        }
                        //카드를 내는 경우
                        else
                        {
                            //카드가 낼 수 있는지 딜러가 현재 문양과 숫자를 보고 판단
                            //맞으면 그대로 제출하도록, 아니면 사용 가능한 카드를 제출하거나 새카드를 뽑을 때까지 재질문
                            if (!dealer.CanPlayCard(player.GetCard(num)))
                            {
                                System.Console.WriteLine("낼 수 없는 카드입니다.");
                                continue;
                            }

                            //카드 개수가 0개인지 확인
                            if (GameIsEnd(players))
                            {
                                break;
                            }

                            //플레이어의 카드를 보드의 필드카드로 보냄
                            Card card = player.PlayCard(num);
                            SetCardToField(card, board, dealer);

                            //문양을 바꾸는 능력은 사용자의 입력을 미리 받아둬야함
                            if (IsChangeAbilityCard(card))
                            {
                                while (true)
                                {
                                    System.Console.WriteLine("어떤 문양으로 변경?  1:♠  2:♣  3:◆  4:♥");
                                    str = System.Console.ReadLine();
                                    try
                                    {
                                        num = Int32.Parse(str);
                                    }
                                    catch (FormatException e)
                                    {
                                        System.Console.WriteLine(e.Message);
                                        continue;
                                    }

                                    dealer.ChangePattern((Card.Pattern)(num - 1));
                                    break;
                                }
                            }

                            //카드의 스페셜 능력 발동, 딜러를 건내줌
                            card.SpecialAbility(dealer);
                        }

                        isPlayCountEnd = true;
                    }
                }

                //게임이 계속 되면 다음 턴으로 넘김
                dealer.SetNextTurn();
            }

            Player winner = GetWinner(players);

            System.Console.WriteLine($"Winner is Player{winner.no}");
        }