コード例 #1
0
    public void DoFlowWork()
    {
        switch (GameData.gameFlow)
        {
        // 아직 게임 시작 안됨
        case Flow.Wait:
        {
            // 로딩 완료 대기
            if (loadingManager.isFinish)
            {
                return;
            }

            // 세이브 파일 로드
            if (GameSaver.useLoad)
            {
                GameSaver.LoadGameInfo();
            }

            // 세이브파일 작성
            // 미구현================
            // 원본에서 복사할것


            // 중력 설정
            if (flowCopy == Flow.Wait)
            {
                Physics.gravity = Physics.gravity * 10;
            }


            // 플레이어 구성 초기화
            {
                if (GameData.gameMode == GameMode.Mode.None)
                {
                    return;
                }
                else if (GameData.gameMode == GameMode.Mode.Online)
                {
                    // 미구현 : 별도 지정 필요===========
                }
                else if (Player.allPlayer.Count == 0)
                {
                    // 중복 방지 작업
                    List <int> picked = Tool.RandomNotCross(1, Character.table.Count, 4);
                    if (picked.Contains(Player.me.character.index))
                    {
                        picked.Remove(Player.me.character.index);
                    }

                    // 플레이어 초기화 및 리스트 구성
                    Player.player_1 = Player.me;
                    Player.allPlayer.Add(Player.player_1);

                    if (GameRule.playerCount >= 2)
                    {
                        Player.player_2 = new Player(Player.Type.AI, picked[0], true, "Player02");
                        Player.allPlayer.Add(Player.player_2);
                    }

                    if (GameRule.playerCount >= 3)
                    {
                        Player.player_3 = new Player(Player.Type.AI, picked[1], true, "Player03");
                        Player.allPlayer.Add(Player.player_3);
                    }

                    if (GameRule.playerCount >= 4)
                    {
                        Player.player_4 = new Player(Player.Type.AI, picked[2], true, "Player04");
                        Player.allPlayer.Add(Player.player_4);
                    }

                    // 시스템 플레이어 - 다른 플레이어 설정
                    Player.system.Monster.otherPlayers = new List <Player>(Player.allPlayer);
                }
            }


            // 캐릭터 생성 및 캐릭터 아이콘 로드
            for (int i = 0; i < Player.allPlayer.Count; i++)
            {
                // 대상 플레이어
                Player current = Player.allPlayer[i];

                // 캐릭터 아이콘 로드
                current.LoadFace();

                // "다른 플레이어" 구성
                {
                    // 모든 플레이어 등록
                    for (int j = 0; j < Player.allPlayer.Count; j++)
                    {
                        current.otherPlayers.Add(Player.allPlayer[j]);
                    }

                    // 등록자 본인 제외
                    current.otherPlayers.Remove(current);
                }

                // 캐릭터 생성
                if (Player.allPlayer[i].avatar == null)
                {
                    // 캐릭터 생성
                    current.CreateAvatar(characterParent);
                    current.avatar.name = "p" + (i + 1);

                    // 캐릭터 이동
                    if (current.movement.location == -1)
                    {
                        current.avatar.transform.position = GameData.blockManager.startBlock.position;
                    }
                    else
                    {
                        current.avatar.transform.position = GameData.blockManager.GetBlock(current.movement.location).transform.position;
                    }
                }

                // 미니게임 정보 초기화
                if (Player.allPlayer[i].miniInfo == null)
                {
                    Player.allPlayer[i].miniInfo = new MiniScore();
                }
            }


            // PlayerInfo UI 비활성
            MainUI.GetComponent <CanvasGroup>().alpha = 0f;
            MainUI.blocksRaycasts = false;


            // 숏컷 등록
            ShortcutManager.script.SetUp();

            // 사이클 설정
            Cycle.goal = GameRule.cycleMax;


            // 세이브 파일 로드
            if (GameSaver.useLoad)
            {
                GameSaver.LoadPlayer();
                GameSaver.LoadItemObject();
                GameSaver.LoadEventObject();
            }

            // 캐릭터 겹침 해소
            //Player.me.movement.AvatarOverFix();
            CharacterMover.AvatarOverFixAll();


            Debug.Log("게임 플로우 :: 새 게임 호출 확인됨");
            GameData.gameFlow = Flow.Start;
            break;
        }


        // 게임 시작됨
        case Flow.Start:
        {
            // 로딩중일 경우 대기
            if (!loadingManager.isFinish || !loadingManager.isFadeFinish)
            {
                return;
            }


            // 맵 둘러보기
            // 미구현==================

            Debug.Log("게임 플로우 :: 게임 시작 확인됨");
            GameData.gameFlow = Flow.Ordering;
            break;
        }


        // 순서주사위
        case Flow.Ordering:
            // 순서주사위 굴리기
        {
            // 씬 재로드 제어
            if (flowCopy <= Flow.Ordering && !GameSaver.useLoad)
            {
                //Debug.Log("게임 플로우 :: 순서 주사위 확인중");

                // 주사위를 아무도 굴리지 않을때
                if (diceController.isFree)
                {
                    // 플레이어별 체크
                    for (int i = 0; i < Player.allPlayer.Count; i++)
                    {
                        Player current = Player.allPlayer[i];

                        // 이미 굴렸으면 다음 플레이어 처리
                        if (current.dice.isRolled)
                        {
                            continue;
                        }

                        // 해당 플레이어가 굴리고 있지 않으면 주사위 호출
                        if (!current.dice.isRolling)
                        {
                            Debug.Log(string.Format("게임 플로우 :: Player{0} 주사위 굴리는중", i + 1));

                            // 주사위 지급
                            Player.allPlayer[i].dice.count = 1;

                            // 주사위 기능 호출
                            diceController.CallDice(
                                current,
                                current.avatar.transform
                                );

                            // 다른 플레이어 무시
                            break;
                        }
                    }
                }

                // 주사위 마무리
                if (diceController.isFinish)
                {
                    diceController.UseDice();
                }

                // 모두가 주사위 굴리지 않으면 중단
                for (int i = 0; i < Player.allPlayer.Count; i++)
                {
                    if (!Player.allPlayer[i].dice.isRolled)
                    {
                        return;
                    }
                }

                Debug.Log("게임 플로우 :: 모든 플레이어 주사위 굴림 완료 =>" + Player.allPlayer.Count);
            }
            else
            {
                // 씬 재로드시 Opening 스킵
                // 아래 PlayerInfo UI 초기화 문제로 return하면 안됨
                GameData.gameFlow = Flow.Cycling;
            }


            // 순서용 리스트 복사
            List <Player> pOrderList = new List <Player>(Player.allPlayer);
            //Debug.Log("게임 플로우 :: 리스트 복사 체크 =>" + pOrderList.Count + " = " + Player.allPlayer.Count);

            // 순서큐 셋팅 및 리스트 순차 정리
            Turn.SetUp(pOrderList);

            // 모든 플레이어 주사위 굴림완료 상태 초기화
            for (int i = 0; i < Player.allPlayer.Count; i++)
            {
                Player.allPlayer[i].dice.Clear();
            }

            // PlayerInfo UI 초기화
            for (int i = 0; i < pOrderList.Count; i++)
            {
                pOrderList[i].infoUI = playerInfoUI[i];
                pOrderList[i].infoUI.SetPlayer(pOrderList[i]);
            }

            // 미할당 PlayerInfo UI 제거
            for (int i = Player.allPlayer.Count; i < playerInfoUI.Count; i++)
            {
                playerInfoUI[i].gameObject.SetActive(false);
            }

            // 세이브 파일 로드
            if (GameSaver.useLoad)
            {
                GameSaver.LoadPlayerInventory();

                // 스타트 플레이어 강제 호출
                TurnWork();

                GameSaver.LoadTurn();
            }
            GameSaver.Clear();

            //// 순서큐 셋팅 및 리스트 순차 정리
            //Turn.SetUp(pOrderList);

            // PlayerInfo UI 활성
            StartCoroutine(Tool.CanvasFade(MainUI, true, 1.5f));
            MainUI.blocksRaycasts = true;


            //GameData.gameFlow = Flow.CycleStart;
            GameData.gameFlow = Flow.Opening;
            break;
        }


        // 사이클링 시작 전 오프닝 단계
        case Flow.Opening:
        {
            // 연출 일단 생략


            // 턴 시작
            if (Cycle.now == 0)
            {
                Cycle.now = 1;
            }

            GameData.gameFlow = Flow.Cycling;
            break;
        }


        // 게임 진행
        case Flow.Cycling:
            if (Cycle.isEnd())
            {
                Debug.Log("게임 플로우 :: 종료 조건 달성 확인됨 => by " + Turn.now.name);
                GameData.gameFlow = Flow.End;
            }
            else
            {
                TurnWork();
            }
            break;


        /*
         * case Flow.Turn:
         * if (Turn.now == Player.system.Minigame)
         *  GameData.gameFlow = Flow.MiniGameStart;
         * else if (Turn.now == Player.system.Ender)
         *  GameData.gameFlow = Flow.CycleEnd;
         * break;
         * case Flow.MiniGameStart:
         * GameData.gameFlow = Flow.MiniGame;
         * break;
         * case Flow.MiniGame:
         * GameData.gameFlow = Flow.MiniGameEnd;
         * break;
         * case Flow.MiniGameEnd:
         * GameData.gameFlow = Flow.Turn;      // 주의 : 다시 턴으로 돌아가서 시스템 플레이어 엔더 역할 수행됨
         * break;
         * case Flow.CycleEnd:
         * if(Cycle.isEnd())
         *  GameData.gameFlow = Flow.End;
         * else
         *  GameData.gameFlow = Flow.CycleStart;
         * break;
         */


        // 게임 종료됨
        case Flow.End:
            GameData.gameFlow = Flow.Trophy;
            break;


        // 트로피 지급 및 우승자 발표
        case Flow.Trophy:
            GameData.gameFlow = Flow.Finish;
            break;


        // 게임 종료됨
        case Flow.Finish:
            break;
        }
    }