/// <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));
}
