示例#1
0
        private void onEnd(Combat.CombatMode.EUserGameState state)
        {
            string winnerName = null;

            switch (state)
            {
            case Combat.CombatMode.EUserGameState.Win:
                winnerName            = _userName;
                _userFirstResultLines = Def.EXAM_USER_WIN;
                _rivalResultLines     = _exam.RivalLose;
                _userResultLines      = _exam.UserWin;
                break;

            case Combat.CombatMode.EUserGameState.Lose:
                winnerName            = _rivalName;
                _userFirstResultLines = Def.EXAM_USER_LOSE;
                _rivalResultLines     = _exam.RivalWin;
                _userResultLines      = _exam.UserLose;
                break;

            default:
                Log.Error(string.Format("invalid user game state: {0}", state));
                break;
            }

            string resultMsg = string.Format(_exam.NPCEndWinnerName, winnerName);

            DialogueEvent.Invoke(NPCId, resultMsg);
        }
示例#2
0
        protected override IEnumerator ExamRoutine()
        {
            DialogueEvent.Invoke(NPCId, _exam.NPCAlarm);
            yield return(null);

            if (IsFirst)
            {
                DialogueEvent.Invoke(NPCId, _exam.NPCProcessMethod);
                yield return(null);

                DialogueEvent.Invoke(NPCId, _exam.NPCEvaluateMethod);
                yield return(null);
            }

            string startMsg = string.Format(_exam.NPCStartPlayersName, _userName, _rivalName);

            DialogueEvent.Invoke(NPCId, startMsg);
            yield return(null);

            DialogueEvent.Invoke(Def.EXAM_USER_START);
            yield return(null);

            //
            Combat.UserPlayer userPlayer = new Combat.UserPlayer(Manager.Instance.Object.CombatMode);
            Combat.AIPlayer   aiPlayer   = getRivalPlayer(_rival.combatPlayerId, userPlayer);

            Manager.Instance.Object.CombatMode.Start(userPlayer, aiPlayer);
            yield return(null);

            Manager.Instance.Object.CombatMode.EndEvent.Detach(onEnd);

            // RIVAL
            if (IsFirst)
            {
                DialogueEvent.Invoke(_userFirstResultLines);
                yield return(null);

                Manager.Instance.Object.StoryMode.LoadScenario(_rival.firstMeetScenarioPath);
            }
            else
            {
                DialogueEvent.Invoke(_rival, _rivalResultLines);
                yield return(null);

                DialogueEvent.Invoke(_userResultLines);
                yield return(null);
            }
        }
示例#3
0
        // constructor
        protected Exam(EType type, int id, int npcId, int rivalId, bool isFirst)
        {
            _type = type;
            _id = id;
            _npcId = npcId;
            _rivalId = rivalId;
            _isFirst = isFirst;

            if (ExtRival.isValid(_rivalId))
                _rival = Manager.Instance.DT.Rival[_rivalId];
            else
                Log.Error(string.Format("invalid rival id: {0}", _rivalId));

            _iterator = null;

            _startEvent = new StartEvent();
            _endEvent = new EndEvent();
            _dialogueEvent = new DialogueEvent();
        }
示例#4
0
        protected override IEnumerator ExamRoutine()
        {
            DialogueEvent.Invoke(NPCId, _exam.NPCAlarm);
            yield return null;

            if (IsFirst)
            {
                DialogueEvent.Invoke(NPCId, _exam.NPCProcessMethod);
                yield return null;

                DialogueEvent.Invoke(NPCId, _exam.NPCEvaluateMethod);
                yield return null;
            }

            DialogueEvent.Invoke(NPCId, _exam.NPCStart);
            yield return null;

            DialogueEvent.Invoke(Def.EXAM_USER_START);
            yield return null;

            // SCORE
            Score.UserPlayer user = new Score.UserPlayer();

            int userScore = _mode.GetScore(user, _statWeight);
            Log.Debug(string.Format("user score: {0}", userScore));

            Score.EGrade userGrade = _mode.GetGrade(userScore);
            Log.Debug(string.Format("user grade : {0}", userGrade));

            //
            string userPoem = user.GetPoem(userGrade);
            DialogueEvent.Invoke(userPoem);
            yield return null;

            DialogueEvent.Invoke(NPCId, _exam.NPCEnd);
            yield return null;

            string userName = Manager.Instance.Object.MainCharacter.Name;
            string usernameMsg = string.Format(_exam.NPCUserNameMsg, userName);
            DialogueEvent.Invoke(NPCId, usernameMsg);
            yield return null;

            string scoreMsg = string.Format(_exam.NPCScoreMsg, userScore);
            DialogueEvent.Invoke(NPCId, scoreMsg);
            yield return null;

            DialogueEvent.Invoke(NPCId, getNPCComment(userGrade));
            yield return null;

            // REWARD
            string rewardMsg = reward(userGrade);

            //
            string userReactMsg = string.Format("{0}{1}", user.GetCommentReact(userGrade), rewardMsg);
            DialogueEvent.Invoke(userReactMsg);
            yield return null;
            
            // RIVAL
            if (IsFirst)
            {
                Manager.Instance.Object.StoryMode.LoadScenario(_rival.firstMeetScenarioPath);
                yield break;
            }

            // RIVAL : compare score
            Score.AIPlayer aiPlayer = getRivalPlayer(_rival.scorePlayerId, user);

            int aiScore = _mode.GetScore(aiPlayer, _statWeight);
            Log.Debug(string.Format("ai score: {0}", aiScore));

            if (userScore == aiScore)
            {
                if (userScore <= Score.ScoreMode.MIN_SCORE)
                    ++aiScore;
                else if (userScore >= Score.ScoreMode.PERFECT_SCORE)
                    --aiScore;
                else
                    judgeSameScore(user.Stress, aiPlayer.Stress, ref aiScore);

                Log.Debug(string.Format("fixed ai score: {0}", aiScore));
            }

            string rivalLines = null;
            string userLines = null;
            if (userScore > aiScore)
            {
                rivalLines = _exam.RivalLose;
                userLines = _exam.UserWin;
            }
            else
            {
                rivalLines = _exam.RivalWin;
                userLines = _exam.UserLose;
            }

            string rivalScoreLines = string.Format(rivalLines, aiScore);
            DialogueEvent.Invoke(_rival, rivalScoreLines);
            yield return null;

            DialogueEvent.Invoke(userLines);
            yield return null;

        }   // end routine