/// <summary> /// Build the quiz asynchronously. /// </summary> /// <param name="nbAnwsers"></param> /// <param name="type"></param> /// <returns></returns> private async Task <Quiz> GenerateQuizAsync(byte nbAnwsers, KanaType type) { IsCreatable(nbAnwsers, type); var rng = new Random(); var answers = new List <Kana>(); // Get all the kana by type var kanas = (List <Kana>) await _kanaRepository.GetAllByTypeAsync(type); // Add answers to quiz for (var i = 0; i < nbAnwsers; i++) { var idKana = kanas[rng.Next(0, kanas.Count)]; answers.Add(idKana); kanas.Remove(idKana); } // Selection a good answer randomly var goodAnswer = answers[rng.Next(0, answers.Count)]; // Create quiz var quiz = new Quiz { Title = "Guess this Hiragana", Type = type, Answers = answers, GoodAnswer = goodAnswer }; return(quiz); }
public void CreateQuiz_Test(KanaType type) { // Arrange var kanaRepository = Substitute.For <IKanaRepository>(); kanaRepository.GetAllByType(type).Returns(_hiraganas); switch (type) { case KanaType.Hiragana: kanaRepository.CountByType(Arg.Any <KanaType>()).Returns((byte)_hiraganas.Count()); break; case KanaType.Katakana: kanaRepository.CountByType(Arg.Any <KanaType>()).Returns((byte)_katakana.Count()); break; } // Act var quizFactory = new QuizFactory(kanaRepository); var result = quizFactory.CreateQuiz(type); // Assert Assert.Equal(4, result.Answers.Count()); Assert.Contains(result.GoodAnswer, result.Answers); }
public void Assemble(int idx, KanaType type) { index = idx; transform.localScale = new Vector3(1.0f, 1.0f, 1.0f); itemText.transform.localScale = Vector3.zero; itemText.transform.DOScale(new Vector3(1.0f, 1.0f, 1.0f), 0.3f).SetEase(Ease.Linear); itemText.text = GamePlayMgr.Instance.GetChoiceKana(index, type); }
private void ChangeKanaType(KanaType type) { if (type == currentKanaType) { return; } ClearCharPanel(); SetCharPanel(type); }
/// <summary> /// Determines if the quiz can be generated. /// </summary> /// <param name="nbAnwsers"></param> /// <param name="type"></param> /// <returns></returns> /// <exception cref="ArgumentException"></exception> private bool IsCreatable(byte nbAnwsers, KanaType type) { if (nbAnwsers >= 2 && nbAnwsers <= _kanaRepository.CountByType(type)) { return(true); } throw new KanaQuizException("The number of responses requested is invalid"); }
private static string ConvertTextBack(string text, KanaType type) { switch (type) { case KanaType.Hiragana: return(HiraganaConverter.Instance.ConvertBack(text)); case KanaType.Katakana: return(KatakanaConverter.Instance.ConvertBack(text)); default: throw new NotImplementedException(); } }
private void LoadLevel() { questionNum++; if (questionNum == 10) { gameCenter.UpdateReportProgress(GameCenterKey.AchieveQuestion10, 50, 50); } if (questionNum == 100) { gameCenter.UpdateReportProgress(GameCenterKey.AchieveQuestion100, 100, 100); } curPassTime = 0; if (level == 1) { level = 2; curLevelQuestion = 0; isStart = true; AddTryNum(); } else if (level < DefineNumber.MaxLevel) { if (curLevelQuestion >= DefineNumber.LevelUpNum) { level++; curLevelQuestion = 0; } curLevelQuestion++; } GamePlayMgr.Instance.GenChoices(level); kanaType = KanaType.Hira; if (questionNum > DefineNumber.QuestionNumToRand) { if (Random.Range(1, 100) >= 50) { kanaType = KanaType.Kata; } } if (questionNum > DefineNumber.HardLevelNum) { passTime = DefineNumber.HardCooldown; rotateSpeed = DefineNumber.HardRotateSpeed; } else { passTime = DefineNumber.Cooldown; rotateSpeed = DefineNumber.RotateSpeed; } question.ShowRiddle(GamePlayMgr.Instance.GetChosenIndex(), kanaType); choice.ShowChoices(level, kanaType); ui.LoadLevel(); RefreshTheme(); }
/// <summary> /// Create a quiz with given type question. /// </summary> /// <param name="type"></param> /// <param name="nbAnwsers"></param> /// <returns></returns> /// <exception cref="NotImplementedException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> public Quiz CreateQuiz(KanaType type, byte nbAnwsers = 4) { var quiz = type switch { KanaType.Hiragana => CreateHiraganaQuiz(nbAnwsers), KanaType.Katakana => CreateKatakanaQuiz(nbAnwsers), KanaType.Kanji => throw new NotImplementedException(), KanaType.Romanji => throw new NotImplementedException(), _ => throw new ArgumentOutOfRangeException(nameof(type), type, "KanaType unknow") }; return(quiz); }
private void SetCharPanel(KanaType type) { string[,] keyboardList = new string[10, 5]; switch (type) { case KanaType.Hiragana: keyboardList = hiraganaForKeyboard; break; case KanaType.Katakana: keyboardList = katakanaForKeyboard; break; case KanaType.lowerCase: keyboardList = lowerCaseForKeyboard; break; case KanaType.UpperCase: keyboardList = UpperCaseForKeyboard; break; } for (int i = 0; i < keyboardList.GetLength(0); i++) { for (int j = 0; j < keyboardList.GetLength(1); j++) { if (keyboardList[i, j] == "") { continue; } GameObject charPanel = (GameObject)Instantiate(charPanelPrefab, transform.position, Quaternion.identity); charPanel.transform.SetParent(CharPanels, false); charPanel.GetComponent <PostTweetPanelForGoCharPanel>().Init(x, y, keyboardList[i, j]); y += intervalOfPanel; } y = 0f; x += intervalOfPanel; } x = 0f; y = 0f; currentKanaType = type; }
public string Transcribe(string text, KanaType toKanaType) { if (toKanaType == KanaType.Romanji) { throw new NotSupportedException(); } var transcriptions = toKanaType == KanaType.Katakana ? this.hiraganaToKatakanaTranscriptions : this.hiraganaToKatakanaTranscriptions.ToDictionary(x => x.Value, x => x.Key); return(text .Select(x => transcriptions.TryGetValue(x.ToString(), out string result) ? result : x.ToString()) .Aggregate(string.Empty, (acc, curr) => acc + curr)); }
public string GetChoiceKana(int index, KanaType type) { if (index >= DefineNumber.AllKanaNum) { return("Err"); } if (type == KanaType.Kata) { return(allHiragana[index]); } if (type == KanaType.Hira) { return(allKatakana[index]); } return("Unknown"); }
public void GameFail(int riddle, KanaType type) { gamePanel.SetActive(false); failPanel.SetActive(true); topText.text = "GAME OVER"; topText.fontSize = 128; bottomText.text = LocalizeMgr.Instance.GetString("LKScore") + " : " + director.score.ToString() + "\n" + LocalizeMgr.Instance.GetString("LKHighScore") + director.highScore; string riddleStr = GamePlayMgr.Instance.GetKana(riddle, type); string answerStr = ""; if (type == KanaType.Hira) { answerStr = GamePlayMgr.Instance.GetKana(riddle, KanaType.Kata); } else { answerStr = GamePlayMgr.Instance.GetKana(riddle, KanaType.Hira); } failScoreText.text = riddleStr + " : " + answerStr; RefreshSoundIcon(); }
public async Task <uint> CountByTypeAsync(KanaType type) { return((uint)await _context.Kanas.AsNoTracking().CountAsync(x => x.Type == type)); }
/// <summary> /// Create a quiz with given type question asynchronous. /// </summary> /// <param name="type">The type.</param> /// <param name="nbAnwsers">The nb anwsers.</param> /// <returns></returns> public Task <Quiz> CreateQuizAsync(KanaType type, byte nbAnwsers = 4) { return(Task.FromResult(CreateQuiz(type, nbAnwsers))); }
public void ShowRiddle(int idx, KanaType type) { index = idx; riddleText.text = GamePlayMgr.Instance.GetKana(idx, type); }
public void SetPreferredKanaType(KanaType value, IDialogContext context) => context.ConversationData.SetValue(ConversationDataSettingsService.PreferredKanaTypeKey, value);
public IEnumerable <Kana> GetAllByType(KanaType type) { return(_context.Kanas.AsNoTracking().Where(x => x.Type == type).ToList()); }
public void ShowChoices(int level, KanaType type) { if (curLevel == level) { List <int> choicesList = GamePlayMgr.Instance.GetChoiceItems(); for (int i = 0; i < choicesObjList.Count; ++i) { choicesObjList[i].GetComponent <ChoiceItem>().Assemble(choicesList[i], type); } } else { ClearChoices(); List <int> choicesList = GamePlayMgr.Instance.GetChoiceItems(); if (level == 1) { GameObject item = Instantiate(Resources.Load("Prefabs/Item") as GameObject); item.transform.SetParent(transform); item.GetComponent <RectTransform>().anchoredPosition = new Vector2(0.0f, 400.0f); item.GetComponent <ChoiceItem>().Assemble(choicesList[0], type); item.name = "Item" + 0; choicesObjList.Add(item); } else if (level == 2) { for (int i = 0; i < level; i++) { GameObject item = Instantiate(Resources.Load("Prefabs/Item") as GameObject); item.transform.SetParent(transform); item.GetComponent <RectTransform>().anchoredPosition = itemPosition2[i]; item.GetComponent <ChoiceItem>().Assemble(choicesList[i], type); item.name = "Item" + i; choicesObjList.Add(item); } } else if (level == 3) { for (int i = 0; i < level; i++) { GameObject item = Instantiate(Resources.Load("Prefabs/Item") as GameObject); item.transform.SetParent(transform); item.GetComponent <RectTransform>().anchoredPosition = itemPosition3[i]; item.GetComponent <ChoiceItem>().Assemble(choicesList[i], type); item.name = "Item" + i; choicesObjList.Add(item); } } else if (level == 4) { for (int i = 0; i < level; i++) { GameObject item = Instantiate(Resources.Load("Prefabs/Item") as GameObject); item.transform.SetParent(transform); item.GetComponent <RectTransform>().anchoredPosition = itemPosition4[i]; item.GetComponent <ChoiceItem>().Assemble(choicesList[i], type); item.name = "Item" + i; choicesObjList.Add(item); } } else if (level == 5) { for (int i = 0; i < level; i++) { GameObject item = Instantiate(Resources.Load("Prefabs/Item") as GameObject); item.transform.SetParent(transform); item.GetComponent <RectTransform>().anchoredPosition = itemPosition5[i]; item.GetComponent <ChoiceItem>().Assemble(choicesList[i], type); item.name = "Item" + i; choicesObjList.Add(item); } } } curLevel = level; }
public async Task <IEnumerable <Kana> > GetAllByTypeAsync(KanaType type) { return(await _context.Kanas.AsNoTracking().Where(x => x.Type == type).ToListAsync()); }
public uint CountByType(KanaType type) { return((uint)_context.Kanas.AsNoTracking().Count(x => x.Type == type)); }