/// <summary>
        /// Prepare all context needed and starts the game.
        /// </summary>
        /// <param name="_gameCode">The game code.</param>
        /// <param name="_gameConfiguration">The game configuration.</param>
        public void StartGame(MiniGameCode _gameCode, GameConfiguration _gameConfiguration)
        {
            if (AppConstants.VerboseLogging)
            {
                Debug.Log("StartGame " + _gameCode.ToString());
            }

            MiniGameData       miniGameData      = AppManager.I.DB.GetMiniGameDataByCode(_gameCode);
            IQuestionBuilder   rules             = null;
            IGameConfiguration currentGameConfig = null;

            currentGameConfig = GetGameConfigurationForMiniGameCode(_gameCode);

            // game difficulty
            currentGameConfig.Difficulty = _gameConfiguration.Difficulty;
            // rule setted in config and used by AI to create correct game data
            rules = currentGameConfig.SetupBuilder();
            // question packs (game data)
            currentGameConfig.Questions = new FindRightLetterQuestionProvider(AppManager.I.GameLauncher.RetrieveQuestionPacks(rules), miniGameData.Description);

            // Save current game code to appmanager currentminigame
            AppManager.I.CurrentMinigame = miniGameData;
            // Comunicate to LogManager that start new single minigame play session.
            currentGameConfig.Context.GetLogManager().InitGameplayLogSession(_gameCode);

            // Call game start
            //NavigationManager.I.GoToNextScene();
            NavigationManager.I.GoToScene(miniGameData.Scene);
        }
示例#2
0
        /// <summary>
        /// Prepare the context and start a minigame.
        /// </summary>
        /// <param name="gameCode">The minigame code.</param>
        /// <param name="launchConfig">The launch configuration. If null, the Teacher will generate a new one.</param>
        public void LaunchGame(MiniGameCode gameCode, MinigameLaunchConfiguration launchConfig)
        {
            LastLaunchConfig = launchConfig;

            ConfigAI.StartTeacherReport();

            var miniGameData = AppManager.I.DB.GetMiniGameDataByCode(gameCode);

            if (launchConfig.DirectGame)
            {
                AppManager.I.NavigationManager.InitNewPlaySession(true, miniGameData);
            }

            if (ApplicationConfig.I.DebugLogEnabled)
            {
                Debug.Log("StartGame " + gameCode.ToString());
                Debug.Log(launchConfig);
            }

            // Assign the configuration for the given minigame
            var minigameSession = DateTime.Now.Ticks.ToString();

            currentGameConfig = ConfigureMiniGameScene(gameCode, minigameSession, launchConfig);

            // Retrieve the packs for the current minigame configuration
            currentQuestionBuilder      = currentGameConfig.SetupBuilder();
            currentQuestionPacks        = questionPacksGenerator.GenerateQuestionPacks(currentQuestionBuilder);
            currentGameConfig.Questions = new SequentialQuestionPackProvider(currentQuestionPacks);

            // Communicate to LogManager the start of a new single minigame play session.
            if (AppConfig.DebugLogDbInserts)
            {
                Debug.Log("InitGameplayLogSession " + gameCode.ToString());
            }
            LogManager.I.LogInfo(InfoEvent.GameStart, "{\"minigame\":\"" + gameCode.ToString() + "\"}");
            LogManager.I.StartMiniGame();

            // Print the teacher's report now
            ConfigAI.PrintTeacherReport();

            // Play the title dialog for the game
            //AudioManager.I.PlayDialogue(_gameCode.ToString()+"_Title");

            // Launch the game
            AppManager.I.NavigationManager.GoToMiniGameScene();
        }
示例#3
0
 public LogGamePlayData(JourneyPosition journeyPosition, MiniGameCode miniGameCode, int stars, float playTime)
 {
     Stage         = journeyPosition.Stage;
     LearningBlock = journeyPosition.LearningBlock;
     PlaySession   = journeyPosition.PlaySession;
     Stars         = stars;
     PlayTime      = (int)playTime;
     MiniGameCode  = miniGameCode.ToString();
     Timestamp     = GenericHelper.GetTimestampForNow();
 }
示例#4
0
        private void CreateButtonForCode(MiniGameCode enumValue)
        {
            MiniGameCode code  = enumValue;
            var          btnGO = Instantiate(buttonPrefab);

            btnGO.transform.SetParent(this.transform);
            btnGO.GetComponentInChildren <Text>().text = (enumValue.ToString()).Replace("_", "\n");
            btnGO.GetComponent <Button>().onClick.AddListener(() => { tester.DoTestMinigame(code); });
            tester.minigamesButtonsDict[enumValue] = btnGO.GetComponent <Button>();
        }
示例#5
0
 /// <summary>
 /// Initializes the single minigame gameplay log session.
 /// </summary>
 public void InitGameplayLogSession(MiniGameCode _minigameCode)
 {
     if (AppConstants.DebugLogInserts)
     {
         Debug.Log("InitGameplayLogSession " + _minigameCode.ToString());
     }
     miniGameCode    = _minigameCode;
     minigameSession = DateTime.Now.Ticks.ToString();
     LogManager.I.LogInfo(InfoEvent.GameStart, miniGameCode.ToString());
 }
示例#6
0
        protected internal void LogMinigameScore(string playSession, MiniGameCode miniGameCode, int score)
        {
            EndMiniGame();
            LogInfo(InfoEvent.GameEnd, JsonUtility.ToJson(new GameResultInfo()
            {
                Game = miniGameCode.ToString(), Result = score.ToString()
            }));

            float duration = (float)(endMiniGameDateTime - startMiniGameDateTime).TotalSeconds;

            //Debug.LogError("DURATION MG: " + duration);
            AppManager.I.Teacher.logAI.LogMiniGameScore(AppSession, AppManager.I.NavigationManager.NavData.CurrentPlayer.CurrentJourneyPosition, miniGameCode, score, duration);
        }
示例#7
0
        public void TrackMiniGameScore(MiniGameCode miniGameCode, int score, JourneyPosition currentJourneyPosition, float duration)
        {
            if (!AnalyticsEnabled)
            {
                return;
            }

            var parameters = new Dictionary <string, object>();

            parameters["minigame_code"]    = miniGameCode.ToString();
            parameters["duration"]         = duration;
            parameters["journey_position"] = currentJourneyPosition.Id;
            AppManager.I.FacebookManager.LogAppEvent("custom_minigame_score", score, parameters);
        }
示例#8
0
        public void LaunchMinigGame(MiniGameCode miniGameCodeSelected)
        {
            Debug.Log("LaunchMinigGame " + miniGameCodeSelected.ToString());
            AppManager.I.Player.CurrentJourneyPosition.Stage         = Stage;
            AppManager.I.Player.CurrentJourneyPosition.LearningBlock = LearningBlock;
            AppManager.I.Player.CurrentJourneyPosition.PlaySession   = PlaySession;

            // We must force this or the teacher won't use the correct data
            AppManager.I.Teacher.InitialiseCurrentPlaySession();

            // Call start game with parameters
            NavigationManager.I.CurrentScene = AppScene.DebugPanel;
            MiniGameAPI.Instance.StartGame(
                miniGameCodeSelected,
                new GameConfiguration(Difficulty)
                );
        }
示例#9
0
 public MiniGameData GetMiniGameDataByCode(MiniGameCode code)
 {
     return(GetMiniGameDataById(code.ToString()));
 }
示例#10
0
        public IGameConfiguration GetGameConfigurationForMiniGameCode(MiniGameCode code)
        {
            IGameConfiguration currentGameConfig = null;

            switch (code)
            {
            case MiniGameCode.Assessment_LetterShape:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.LetterShape;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_WordsWithLetter:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.WordsWithLetter;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_MatchLettersToWord:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.MatchLettersToWord;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_CompleteWord:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.CompleteWord;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_OrderLettersOfWord:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.OrderLettersOfWord;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_VowelOrConsonant:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.VowelOrConsonant;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_SelectPronouncedWord:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.SelectPronouncedWord;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_MatchWordToImage:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.MatchWordToImage;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_WordArticle:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.WordArticle;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_SingularDualPlural:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.SingularDualPlural;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_SunMoonWord:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.SunMoonWord;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_SunMoonLetter:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.SunMoonLetter;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Assessment_QuestionAndReply:
                Assessment.AssessmentConfiguration.Instance.assessmentType = Assessment.AssessmentCode.QuestionAndReply;
                Assessment.AssessmentConfiguration.Instance.Context        = AnturaMinigameContext.Default;
                currentGameConfig = Assessment.AssessmentConfiguration.Instance;
                break;

            case MiniGameCode.Balloons_counting:
                Balloons.BalloonsConfiguration.Instance.Variation = Balloons.BalloonsVariation.Counting;
                Balloons.BalloonsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Balloons.BalloonsConfiguration.Instance;
                break;

            case MiniGameCode.Balloons_letter:
                Balloons.BalloonsConfiguration.Instance.Variation = Balloons.BalloonsVariation.Letter;
                Balloons.BalloonsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Balloons.BalloonsConfiguration.Instance;
                break;

            case MiniGameCode.Balloons_spelling:
                Balloons.BalloonsConfiguration.Instance.Variation = Balloons.BalloonsVariation.Spelling;
                Balloons.BalloonsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Balloons.BalloonsConfiguration.Instance;
                break;

            case MiniGameCode.Balloons_words:
                Balloons.BalloonsConfiguration.Instance.Variation = Balloons.BalloonsVariation.Words;
                Balloons.BalloonsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Balloons.BalloonsConfiguration.Instance;
                break;

            case MiniGameCode.ColorTickle:
                ColorTickle.ColorTickleConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = ColorTickle.ColorTickleConfiguration.Instance;
                break;

            case MiniGameCode.DancingDots:
                DancingDots.DancingDotsConfiguration.Instance.Variation = DancingDots.DancingDotsVariation.V_1;
                DancingDots.DancingDotsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = DancingDots.DancingDotsConfiguration.Instance;
                break;

            case MiniGameCode.DontWakeUp:
                //
                break;

            case MiniGameCode.Egg:
                Egg.EggConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = Egg.EggConfiguration.Instance;
                break;

            case MiniGameCode.FastCrowd_alphabet:
                FastCrowd.FastCrowdConfiguration.Instance.Variation = FastCrowd.FastCrowdVariation.Alphabet;
                FastCrowd.FastCrowdConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = FastCrowd.FastCrowdConfiguration.Instance;
                break;

            case MiniGameCode.FastCrowd_counting:
                FastCrowd.FastCrowdConfiguration.Instance.Variation = FastCrowd.FastCrowdVariation.Counting;
                FastCrowd.FastCrowdConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = FastCrowd.FastCrowdConfiguration.Instance;
                break;

            case MiniGameCode.FastCrowd_letter:
                FastCrowd.FastCrowdConfiguration.Instance.Variation = FastCrowd.FastCrowdVariation.Letter;
                FastCrowd.FastCrowdConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = FastCrowd.FastCrowdConfiguration.Instance;
                break;

            case MiniGameCode.FastCrowd_spelling:
                FastCrowd.FastCrowdConfiguration.Instance.Variation = FastCrowd.FastCrowdVariation.Spelling;
                FastCrowd.FastCrowdConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = FastCrowd.FastCrowdConfiguration.Instance;
                break;

            case MiniGameCode.FastCrowd_words:
                FastCrowd.FastCrowdConfiguration.Instance.Variation = FastCrowd.FastCrowdVariation.Words;
                FastCrowd.FastCrowdConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = FastCrowd.FastCrowdConfiguration.Instance;
                break;

            case MiniGameCode.TakeMeHome:
                TakeMeHome.TakeMeHomeConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = TakeMeHome.TakeMeHomeConfiguration.Instance;
                break;

            case MiniGameCode.HiddenSource:
                // It has now become TakeMeHome
                break;

            case MiniGameCode.HideSeek:
                HideAndSeek.HideAndSeekConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = HideAndSeek.HideAndSeekConfiguration.Instance;
                break;

            case MiniGameCode.MakeFriends:
                MakeFriends.MakeFriendsConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = MakeFriends.MakeFriendsConfiguration.Instance;
                break;

            case MiniGameCode.Maze:
                Maze.MazeConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = Maze.MazeConfiguration.Instance;
                break;

            case MiniGameCode.MissingLetter:
                MissingLetter.MissingLetterConfiguration.Instance.Variation = MissingLetter.MissingLetterVariation.MissingLetter;
                MissingLetter.MissingLetterConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = MissingLetter.MissingLetterConfiguration.Instance;
                break;

            case MiniGameCode.MissingLetter_phrases:
                MissingLetter.MissingLetterConfiguration.Instance.Variation = MissingLetter.MissingLetterVariation.MissingWord;
                MissingLetter.MissingLetterConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = MissingLetter.MissingLetterConfiguration.Instance;
                break;

            case MiniGameCode.MixedLetters_alphabet:
                // TODO: set variation
                MixedLetters.MixedLettersConfiguration.Instance.Variation = MixedLetters.MixedLettersConfiguration.MixedLettersVariation.Alphabet;
                MixedLetters.MixedLettersConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = MixedLetters.MixedLettersConfiguration.Instance;
                break;

            case MiniGameCode.MixedLetters_spelling:
                MixedLetters.MixedLettersConfiguration.Instance.Variation = MixedLetters.MixedLettersConfiguration.MixedLettersVariation.Spelling;
                MixedLetters.MixedLettersConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = MixedLetters.MixedLettersConfiguration.Instance;
                break;

            case MiniGameCode.SickLetters:
                SickLetters.SickLettersConfiguration.Instance.Context = AnturaMinigameContext.Default;
                currentGameConfig = SickLetters.SickLettersConfiguration.Instance;
                break;

            case MiniGameCode.ReadingGame:
                ReadingGame.ReadingGameConfiguration.Instance.Variation = ReadingGame.ReadingGameVariation.ReadAndAnswer;
                ReadingGame.ReadingGameConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = ReadingGame.ReadingGameConfiguration.Instance;
                break;

            case MiniGameCode.AlphabetSong:
                ReadingGame.ReadingGameConfiguration.Instance.Variation = ReadingGame.ReadingGameVariation.AlphabetSong;
                ReadingGame.ReadingGameConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = ReadingGame.ReadingGameConfiguration.Instance;
                break;

            case MiniGameCode.Scanner:
                Scanner.ScannerConfiguration.Instance.Variation = Scanner.ScannerVariation.OneWord;
                Scanner.ScannerConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Scanner.ScannerConfiguration.Instance;
                break;

            case MiniGameCode.Scanner_phrase:
                Scanner.ScannerConfiguration.Instance.Variation = Scanner.ScannerVariation.MultipleWords;
                Scanner.ScannerConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Scanner.ScannerConfiguration.Instance;
                break;

            case MiniGameCode.ThrowBalls_letters:
                ThrowBalls.ThrowBallsConfiguration.Instance.Variation = ThrowBalls.ThrowBallsVariation.letters;
                ThrowBalls.ThrowBallsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = ThrowBalls.ThrowBallsConfiguration.Instance;
                break;

            case MiniGameCode.ThrowBalls_words:
                ThrowBalls.ThrowBallsConfiguration.Instance.Variation = ThrowBalls.ThrowBallsVariation.words;
                ThrowBalls.ThrowBallsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = ThrowBalls.ThrowBallsConfiguration.Instance;
                break;

            case MiniGameCode.ThrowBalls_letterinword:
                ThrowBalls.ThrowBallsConfiguration.Instance.Variation = ThrowBalls.ThrowBallsVariation.lettersinword;
                ThrowBalls.ThrowBallsConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = ThrowBalls.ThrowBallsConfiguration.Instance;
                break;

            case MiniGameCode.Tobogan_letters:
                Tobogan.ToboganConfiguration.Instance.Variation = Tobogan.ToboganVariation.LetterInAWord;
                Tobogan.ToboganConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Tobogan.ToboganConfiguration.Instance;
                break;

            case MiniGameCode.Tobogan_words:
                Tobogan.ToboganConfiguration.Instance.Variation = Tobogan.ToboganVariation.SunMoon;
                Tobogan.ToboganConfiguration.Instance.Context   = AnturaMinigameContext.Default;
                currentGameConfig = Tobogan.ToboganConfiguration.Instance;
                break;

            default:
                Debug.LogWarningFormat("Minigame selected {0} not found.", code.ToString());
                break;
            }
            return(currentGameConfig);
        }
示例#11
0
        /// <summary>
        /// Prepare the context and start a minigame.
        /// </summary>
        /// <param name="_gameCode">The minigame code.</param>
        /// <param name="_launchConfiguration">The launch configuration. If null, the Teacher will generate a new one.</param>
        /// <param name="forceNewPlaySession">Is this a new play session?</param>
        public void LaunchGame(MiniGameCode _gameCode, MinigameLaunchConfiguration _launchConfiguration = null,
                               bool forceNewPlaySession = false)
        {
            ConfigAI.StartTeacherReport();
            if (_launchConfiguration == null)
            {
                var difficulty      = teacher.GetCurrentDifficulty(_gameCode);
                var numberOfRounds  = teacher.GetCurrentNumberOfRounds(_gameCode);
                var tutorialEnabled = teacher.GetTutorialEnabled(_gameCode);
                _launchConfiguration = new MinigameLaunchConfiguration(difficulty, numberOfRounds, tutorialEnabled);
            }

            var miniGameData = AppManager.I.DB.GetMiniGameDataByCode(_gameCode);

            if (forceNewPlaySession)
            {
                AppManager.I.NavigationManager.InitNewPlaySession(miniGameData);
            }

            if (AppConfig.DebugLogEnabled)
            {
                Debug.Log("StartGame " + _gameCode.ToString());
            }

            // Assign the configuration for the given minigame
            var minigameSession = System.DateTime.Now.Ticks.ToString();

            currentGameConfig                 = ConfigureMiniGameScene(_gameCode, minigameSession);
            currentGameConfig.Difficulty      = _launchConfiguration.Difficulty;
            currentGameConfig.TutorialEnabled = _launchConfiguration.TutorialEnabled;

            // Set also the number of rounds
            // @note: only for assessment, for now
            if (currentGameConfig is Assessment.IAssessmentConfiguration)
            {
                var assessmentConfig = currentGameConfig as Assessment.IAssessmentConfiguration;
                assessmentConfig.NumberOfRounds = _launchConfiguration.NumberOfRounds;
            }

            // Retrieve the packs for the current minigame configuration
            currentQuestionBuilder      = currentGameConfig.SetupBuilder();
            currentQuestionPacks        = questionPacksGenerator.GenerateQuestionPacks(currentQuestionBuilder);
            currentGameConfig.Questions = new SequentialQuestionPackProvider(currentQuestionPacks);

            // Communicate to LogManager the start of a new single minigame play session.
            if (AppConfig.DebugLogDbInserts)
            {
                Debug.Log("InitGameplayLogSession " + _gameCode.ToString());
            }
            LogManager.I.LogInfo(InfoEvent.GameStart, "{\"minigame\":\"" + _gameCode.ToString() + "\"}");
            LogManager.I.StartMiniGame();

            // Print the teacher's report now
            ConfigAI.PrintTeacherReport();

            // Play the title dialog for the game
            //AudioManager.I.PlayDialogue(_gameCode.ToString()+"_Title");

            // Launch the game
            AppManager.I.NavigationManager.GoToMiniGameScene();
        }
 public string GetId()
 {
     return(Code.ToString());
 }
示例#13
0
 private string GetDictKey(MiniGameCode minigameCode, float difficulty)
 {
     return(minigameCode.ToString() + difficulty.ToString("F1"));
 }