public ActionResult AddKanji(Kanji newKanji)
{
if (ModelState.IsValid)
{
var serviceClient = new JapaneseServiceClient();
serviceClient.InsertKanji(newKanji);
}
return View(newKanji);
}
public IHttpActionResult DeleteKanji(int id)
{
Kanji kanji = db.Kanjis.Find(id);
if (kanji == null)
{
return(NotFound());
}
db.Kanjis.Remove(kanji);
db.SaveChanges();
return(Ok(kanji));
}
public void TestEquals()
{
var current = new Kanji("Test", "Test");
var otherObj = new object();
var otherKanji = new Kanji("Test1", "Test");
var equalKanji = new Kanji("Test", "Test");
var thisKanji = current;
Assert.IsTrue(current.Equals(equalKanji));
Assert.IsTrue(current.Equals(thisKanji));
Assert.IsFalse(current.Equals(null));
Assert.IsFalse(current.Equals(otherObj));
Assert.IsFalse(current.Equals(otherKanji));
}
// GET: Kanji/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Kanji kanji = db.Kanji.Find(id);
if (kanji == null)
{
return(HttpNotFound());
}
return(View(kanji));
}
List <Kanji> ShuffleKanjiList(List <Kanji> L)
{
int c = L.Count;
int lt = L.Count - 1;
for (int j = 0; j < lt; ++j)
{
int r = UnityEngine.Random.Range(j, c);
Kanji tmp = L[j];
L[j] = L[r];
L[r] = tmp;
}
return(L);
}
// Update is called once per frame
void Update()
{
if (kanjiNum == 0)
{
captionA.text = "One";
captionB.text = "Ichi";
captionC.text = "いち";
}
if (kanjiNum == 1)
{
captionA.text = "Two";
captionB.text = "Ni";
captionC.text = "に";
}
if (kanjiNum == 2)
{
captionA.text = "Three";
captionB.text = "San";
captionC.text = "さん";
}
if (kanjiNum == 3)
{
captionA.text = "Four";
captionB.text = "Yon";
captionC.text = "よん";
}
if (kanjiNum == 4)
{
captionA.text = "Five";
captionB.text = "Go";
captionC.text = "ご";
}
if (current.completed)
{
if (kanjiNum < kanjis.Count - 1)
{
print("Kanji complete! Moving on to next...");
kanjiNum++;
Destroy(current);
current = Instantiate(kanjis[kanjiNum]);
current.enabled = true;
current.transform.parent = transform;
}
else
{
print("Game completed!");
}
}
}
void SelectKanji()
{
GUI.FocusControl(null);
if (selKanji == -1)
{
// Nothing selected
kanjiBase.ResetValues();
}
else
{
// Something selected
Kanji ce = (Kanji)kanjiLibrary.GetEntryByIndex(selKanji);
kanjiBase.CopyValues(ce);
}
}
/// <summary>
/// Adds or merge a kanji to the kanji dictionary.
/// </summary>
/// <param name="k">Kanji to add or merge.</param>
private void AddKanjiEntry(Kanji k)
{
if (_kanjiDictionary.ContainsKey(k.Character))
{
_kanjiDictionary[k.Character].Readings.AddRange(k.Readings);
_kanjiDictionary[k.Character].Readings = _kanjiDictionary[k.Character].Readings.Distinct().ToList();
_kanjiDictionary[k.Character].ReadingsWithNanori.AddRange(k.ReadingsWithNanori);
_kanjiDictionary[k.Character].ReadingsWithNanori = _kanjiDictionary[k.Character].ReadingsWithNanori.Distinct().ToList();
}
else
{
_kanjiDictionary.Add(k.Character, k);
}
}
public void Awake()
{
for (int i = 0; i < KanjiButtonList.Count; i++)
{
Kanji iKanji = GameController.instance.GetTodayKanji(i);
if (iKanji == null)
{
KanjiButtonList[i].gameObject.SetActive(false);
}
else
{
KanjiButtonList[i].SetData(iKanji);
}
}
ChangeMainInfo(0);
}
public void SetMnemonics(Kanji item)
{
string input = item.data.meaning_mnemonic;
string inputReading = item.data.reading_mnemonic;
var meaningText = CreateMnemonicTextBlock(input);
mainRelative.Children.Add(meaningText);
if (!String.IsNullOrEmpty(inputReading))
{
var readingText = CreateMnemonicTextBlock(inputReading);
subRel.Children.Add(readingText);
RelativePanel.SetBelow(readingText, ReadingSubd);
}
RelativePanel.SetBelow(meaningText, MeaningSub);
}
public DetailKanjiItem(Kanji kanji)
{
InitializeComponent();
this.kanji = kanji;
kanjiTextblock.Text = kanji.kanji;
onyomiTextblock.Text = kanji.onyomi;
kunyomiTextblock.Text = kanji.kunyomi;
meaningTextblock.Text = kanji.meaning;
exampleTextblock.Text = kanji.example;
kanjiTabTextblock.Visibility = System.Windows.Visibility.Collapsed;
onyomiTabTextblock.Visibility = System.Windows.Visibility.Collapsed;
kunyomiTabTextblock.Visibility = System.Windows.Visibility.Collapsed;
exampleTabTextblock.Visibility = System.Windows.Visibility.Collapsed;
}
public static FlowDocument Build(Kanji kanji)
{
if (kanji == null)
{
return(null);
}
//start build
FlowDocument document = new FlowDocument()
{
PagePadding = new Thickness(10)
};
document.Blocks.Add(BuildGeneralInfo(kanji));
document.Blocks.Add(BuildWords(kanji.Word, kanji.Kunyomi));
return(document);
}
public static void SortByTimestamp(List <Kanji> kanjis)
{
//after this, sort these timestamp array and make every step for both
//the timestamp array and the Words array
for (int i = 0; i < kanjis.Count - 1; ++i)
{
for (int j = i + 1; j < kanjis.Count; ++j)
{
if (kanjis[i].timestamp > kanjis[j].timestamp)
{
Kanji hv = kanjis[i];
kanjis[i] = kanjis[j];
kanjis[j] = hv;
}
}
}
}
/// <summary>
/// Copies the values from another entry.
/// </summary>
/// <param name="other"></param>
public override void CopyValues(ScrObjLibraryEntry other)
{
base.CopyValues(other);
Kanji kanji = (Kanji)other;
activations = new List <KanjiActivation>();
for (int i = 0; i < kanji.activations.Count; i++)
{
activations.Add(kanji.activations[i]);
}
effects = new List <KanjiEffect>();
for (int i = 0; i < kanji.effects.Count; i++)
{
effects.Add(kanji.effects[i]);
}
values.CopyValues(kanji.values);
}
public static void EvaluateKanji(int grade)
{
Kanji activeKanji = FlashcardsData.ActiveKanji;
int lastRound = activeKanji.lastRound;
int nextRound = activeKanji.nextRound;
int repetition = nextRound - lastRound;
activeKanji.timestamp = ++AppSettings.TimeStamp;
if (grade > 2)
{
if (repetition == 0)
{
++nextRound;
}
else if (repetition == 1)
{
nextRound += 3;
}
else
{
nextRound = lastRound + (int)Math.Round(repetition * activeKanji.eFactor);
}
--FlashcardsData.ItemsLeft;
++FlashcardsData.ItemsCorrect;
}
else
{
nextRound = AppSettings.KanjiRound;
++FlashcardsData.ItemsWrong;
FlashcardsData.ActiveKanjis.Add(activeKanji);
}
lastRound = AppSettings.KanjiRound;
activeKanji.eFactor += -0.8f + 0.28f * grade - 0.02f * grade * grade;
activeKanji.eFactor = Math.Max(1.3f, activeKanji.eFactor);
activeKanji.nextRound = nextRound;
activeKanji.lastRound = lastRound;
}
public static async Task <Kanji> DownloadKanji(HttpClient http, string character)
{
string url = "http://kanjiapi.dev/v1/kanji/" + character;
//Query API
HttpResponseMessage res = await http.GetAsync(url);
HttpContent content = res.Content;
var data = await content.ReadAsStringAsync();
JObject obj = JObject.Parse(data);
//Meanings
List <string> meanings = JArrayToStringList(JArray.Parse(obj["meanings"].ToString()));
//Kun
List <string> kun = JArrayToStringList(JArray.Parse(obj["kun_readings"].ToString()));
//On
List <string> on = JArrayToStringList(JArray.Parse(obj["on_readings"].ToString()));
//Name
List <string> names = JArrayToStringList(JArray.Parse(obj["name_readings"].ToString()));
//Grade
int grade = Int32.Parse(obj["grade"].ToString());
//JLPT
int jlpt = Int32.Parse(obj["jlpt"].ToString());
//Unicode
string unicode = obj["unicode"].ToString();
//Heisig
string heisig = obj["heisig_en"].ToString();
//Strokes
int strokes = Int32.Parse(obj["stroke_count"].ToString());
Kanji k = new Kanji(
obj["kanji"].ToString(),
meanings,
kun,
on,
names,
grade,
jlpt,
strokes,
unicode,
heisig);
return(k);
}
void DeleteKanji()
{
GUI.FocusControl(null);
Kanji c = (Kanji)kanjiLibrary.GetEntryByIndex(selKanji);
string path = "Assets/LibraryData/Kanji/" + c.uuid + ".asset";
kanjiLibrary.RemoveEntryByIndex(selKanji);
Undo.RecordObject(kanjiLibrary, "Deleted kanji");
EditorUtility.SetDirty(kanjiLibrary);
bool res = AssetDatabase.MoveAssetToTrash(path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
if (res)
{
Debug.Log("Removed kanji: " + c.uuid);
selKanji = -1;
}
}
//static List<Kanji> GetBasicKanjis() {
// List<Structure> basicStructure = DatabaseContext.Structures
// .Where(s => s.Kanji.Character == s.StructureString)
// .ToList();
// List<long> basicKanjiIds = basicStructure.Select(s => s.KanjiId).ToList();
// return DatabaseContext.Kanjis
// .Where(k => basicKanjiIds.Contains(k.Id))
// .ToList();
//}
static Kanji GetKanjiRecord(string kanji)
{
if (KanjiDict.ContainsKey(kanji))
{
return(KanjiDict[kanji]);
}
Kanji kanjiRecord = DatabaseContext.Kanjis.Include(k => k.Structures).SingleOrDefault(k => k.Character == kanji);
if (kanjiRecord == null)
{
kanjiRecord = new Kanji {
Character = kanji,
Structures = new Structure[] {}
};
DatabaseContext.Kanjis.Add(kanjiRecord);
DatabaseContext.SaveChanges();
}
KanjiDict.Add(kanji, kanjiRecord);
return(KanjiDict[kanji]);
}
public WordsForm(Settings settings)
{
error = false;
debug = true;
hiragana = new Hiragana();
katakana = new Katakana();
kanji = new Kanji();
if (debug)
{
Console.WriteLine("Kanji List Length at initialization: " + kanji.getLength());
}
InitializeComponent();
this.settings = settings;
category1 = 45;
category2 = 20;
category3 = 4;
category4 = 32;
}
public void SetCurrentData(System.Object data)
{
_currentItem = null;
_currentKanji = null;
_currentSentence = null;
if (data is LearningSetItem)
{
_currentItem = data as LearningSetItem;
EventBus.Instance.Raise(new DataProxySelectionEvent(_currentItem, NavType.Display, GetKanjiForItem(_currentItem), GetSentencesForItem(_currentItem)));
}
else if (data is ExampleSentence)
{
_currentSentence = data as ExampleSentence;
EventBus.Instance.Raise(new DataProxySelectionEvent(_currentSentence, NavType.Display, GetItemsForSentence(_currentSentence)));
}
else if (data is Kanji)
{
_currentKanji = data as Kanji;
EventBus.Instance.Raise(new DataProxySelectionEvent(_currentKanji, NavType.Display, extendedSet.GetItemsForKanji(_currentKanji)));
}
}
private void ShowKanjiPartOf(Kanji kanji)
{
if (kanji != null)
{
//var window = new KanjiPartOf(kanji) { Owner = this };
//window.ShowDialog();
var panel = new KanjiPanel();
panel.ListKanji.ItemsSource =
JazeDatabaseContext.Context.Kanjis.Where(k => k.Component.Contains(kanji.Word)).ToList();
var window = new Window()
{
WindowStartupLocation = WindowStartupLocation.CenterOwner,
Content = panel,
Owner = this,
WindowStyle = WindowStyle.ToolWindow,
ShowInTaskbar = false
};
window.ShowDialog();
}
}
private static Block BuildAttributeSet(Kanji kanji)
{
List list = new List()
{
MarkerStyle = TextMarkerStyle.Box
};
//add list attribute
list.ListItems.Add(BuildAttribute("Bộ thủ: ", $"{kanji.Radical.Word}({kanji.Radical.HanViet})"));
list.ListItems.Add(BuildAttribute("Cách viết khác: ", kanji.Variant));
list.ListItems.Add(BuildAttribute("Onyomi: ", kanji.Onyomi));
list.ListItems.Add(BuildAttribute("Kunyomi: ", kanji.Kunyomi));
//list.ListItems.Add(BuildKunAttribute(kanji.Kunyomi));
list.ListItems.Add(BuildAttribute("Số nét: ", "" + kanji.Stroke));
list.ListItems.Add(BuildAttribute("Độ phổ biến: ",
kanji.Frequence == int.MaxValue ? "?/2500" : "" + kanji.Frequence + "/2500"));
list.ListItems.Add(BuildAttribute("Trình độ: ", kanji.Level.ToString()));
list.ListItems.Add(BuildAttribute("Thành phần: ", kanji.Component));
list.ListItems.Add(BuildAttribute("Gần giống: ", kanji.Similar));
return(list);
}
/// <summary>
/// Adds the kanji to the inventory.
/// </summary>
/// <param name="kanji"></param>
/// <param name="equip"></param>
void AddKanji(Kanji kanji, bool equip)
{
bool added;
if (equip)
{
added = invKanjiHandler.AddEquip(kanji);
}
else
{
added = invKanjiHandler.AddBag(kanji);
}
if (added)
{
inventoryChanged.Invoke();
}
else
{
Debug.Log("No room left to add kanji.");
}
}
public List <Kanji> GetKanjiForItem(LearningSetItem item)
{
List <Kanji> kanjiList = new List <Kanji> ();
string firstKanji = item.FirstKanji();
if (firstKanji == null)
{
return(kanjiList); // if the item is kana only, this will trigger
}
List <string> itemKanji = firstKanji.Select(k => $"{k}").ToList();
foreach (string iKanji in itemKanji)
{
Kanji foundKanji = kanji.Where(k => k.kanji == iKanji).FirstOrDefault();
if (foundKanji != null)
{
kanjiList.Add(foundKanji);
}
}
return(kanjiList);
}
public void FillKanjiItem(Kanji kanji, bool hideText)
{
FillKanjiItem(kanji);
kanjiHidden = hideText;
onyomiHidden = hideText;
kunyomiHidden = hideText;
exampleHidden = hideText;
if (hideText)
{
kanjiTextblock.Visibility = System.Windows.Visibility.Collapsed;
onyomiTextblock.Visibility = System.Windows.Visibility.Collapsed;
kunyomiTextblock.Visibility = System.Windows.Visibility.Collapsed;
exampleTextblock.Visibility = System.Windows.Visibility.Collapsed;
kanjiTabTextblock.Visibility = System.Windows.Visibility.Visible;
onyomiTabTextblock.Visibility = System.Windows.Visibility.Visible;
kunyomiTabTextblock.Visibility = System.Windows.Visibility.Visible;
exampleTabTextblock.Visibility = System.Windows.Visibility.Visible;
}
}
public IActionResult SearchApi(string keyword)
{
Kanji kanji = Database.Kanjis
.Include(k => k.Structures)
.Include(k => k.MajorParts)
.Include(k => k.MinorParts)
.SingleOrDefault(k => k.Character == keyword);
if (kanji == null)
{
return(NotFoundResponse(ErrorMessages.KanjiNotFound));
}
{
HashSet <long> majorKanjiIds = new HashSet <long>(kanji.MajorParts.Select(p => p.Id));
IDictionary <long, Kanji> majorPartDict = Database.Parts
.Include(p => p.Kanji)
.Where(p => majorKanjiIds.Contains(p.Id))
.ToDictionary(p => p.Id, p => p.Kanji);
foreach (Part part in kanji.MajorParts)
{
part.Kanji = majorPartDict[part.Id];
}
}
{
HashSet <long> minorKanjiIds = new HashSet <long>(kanji.MinorParts.Select(p => p.Id));
IDictionary <long, Kanji> minorPartDict = Database.Parts
.Include(p => p.PartialKanji)
.Where(p => minorKanjiIds.Contains(p.Id))
.ToDictionary(p => p.Id, p => p.PartialKanji);
foreach (Part part in kanji.MinorParts)
{
part.PartialKanji = minorPartDict[part.Id];
}
}
return(OkResponse(new ApiKanjiSearchResultObject(kanji)));
}
private static void TryAddKanji(Kanji kanji)
{
if (kanji.nextRound <= AppSettings.KanjiRound)
{
if (kanji.timestamp == 0)
{
kanji.lastRound = AppSettings.KanjiRound;
kanji.nextRound = AppSettings.KanjiRound;
++newKanjisAdded;
if (newKanjisAdded <= AppSettings.NewKanjiPerRound)
{
FlashcardsData.ActiveKanjis.Add(kanji);
}
}
else
{
FlashcardsData.ActiveKanjis.Add(kanji);
}
}
}
/// <summary>
/// Updates the information text of the currently selected kanji.
/// </summary>
void UpdateValues()
{
if (selectedKanji.reference != null)
{
currentKanji = (Kanji)selectedKanji.reference;
itemName.text = currentKanji.entryName;
itemIcon.sprite = currentKanji.icon;
itemIcon.enabled = true;
values[0].text = currentKanji.values.kanjiType.ToString();
values[1].text = currentKanji.values.damage.ToString();
values[2].text = currentKanji.values.maxCharges.ToString();
values[3].text = (currentKanji.values.cooldown != -1) ? currentKanji.values.cooldown.ToString() + " s" : "-";
}
else
{
itemName.text = "";
itemIcon.enabled = false;
values[0].text = "";
values[1].text = "";
values[2].text = "";
values[3].text = "";
}
}
public void Copy(Kanji entity)
{
if (entity == null)
{
return;
}
Id = entity.Id;
Word = entity.Word;
HanViet = entity.HanViet;
Variant = entity.Variant;
Onyomi = entity.Onyomi;
Kunyomi = entity.Kunyomi;
VieMeaning = entity.VieMeaning;
EngMeaning = entity.EngMeaning;
Stroke = entity.Stroke;
StrokeOrder = entity.StrokeOrder;
Frequence = entity.Frequence;
Similar = entity.Similar;
Component = entity.Component;
Level = entity.Level;
Grade = entity.Grade;
}
private void ShowKanjiPart(Kanji kanji)
{
UserControl control;
if (kanji == null)
{
control = new KanjiPartControl();
}
else
{
control = new KanjiPartControl(kanji);
}
Window window = new Window
{
Content = control,
Owner = this,
WindowStartupLocation = WindowStartupLocation.CenterOwner,
ShowInTaskbar = false
};
window.ShowDialog();
}
/// <summary>
/// Attempts to solve furigana in cases where there are no consecutive kanji in the kanji string,
/// using regular expressions.
/// </summary>
protected override IEnumerable <FuriganaSolution> DoSolve(FuriganaResourceSet r, VocabEntry v)
{
// We are using both a greedy expression and a lazy expression because we want to make sure
// there is only one way to read them. If the result differs with a greedy or a lazy expression,
// it means that we have no idea how to read the damn thing.
string regGreedy = "^";
string regLazy = "^";
bool consecutiveMarker = false;
List <int> kanjiIndexes = new List <int>(4);
for (int i = 0; i < v.KanjiReading.Length; i++)
{
char c = v.KanjiReading[i];
Kanji k = r.GetKanji(c);
if (k == null)
{
// Add the characters to the string. No capture group for kana.
regGreedy += string.Format(c.ToString());
regLazy += string.Format(c.ToString());
consecutiveMarker = false;
}
else if (consecutiveMarker)
{
// Consecutive kanji. The vocab entry is not eligible for this solution.
yield break;
}
else
{
// Add the characters inside a capture group for kanji.
regGreedy += "(.+)";
regLazy += "(.+?)";
consecutiveMarker = true;
kanjiIndexes.Add(i);
}
}
regGreedy += "$";
regLazy += "$";
// Example regex:
// For 持ち運ぶ (もちはこぶ)
// The regexes would be:
// ^(.+)ち(.+)ぶ$
// ^(.+?)ち(.+?)ぶ$
Regex regexGreedy = new Regex(regGreedy);
Regex regexLazy = new Regex(regLazy);
Match matchGreedy = regexGreedy.Match(v.KanaReading);
Match matchLazy = regexLazy.Match(v.KanaReading);
if (matchGreedy.Success && matchLazy.Success)
{
// Obtain both solutions.
FuriganaSolution greedySolution = MakeSolutionFromMatch(v, matchGreedy, kanjiIndexes);
FuriganaSolution lazySolution = MakeSolutionFromMatch(v, matchLazy, kanjiIndexes);
// Are both solutions non-null and equivalent?
if (greedySolution != null && lazySolution != null && greedySolution.Equals(lazySolution))
{
// Yes they are! Return only one of them of course.
// Greedy wins obviously.
yield return(greedySolution);
}
}
}
