Add Katakana, Korean and Thai games and difficulty levels

- decks package: Hiragana, Katakana, Hangul jamo and Thai consonants
  (Thai readings carry the letter's name word, since sounds repeat)
- Per-script fonts: Jua for Hangul, Mali for Thai (both OFL)
- Memory game works with any deck; Easy 3x4, Normal 4x6, Hard 4x8
- Language menus pick a deck and difficulty, with number/arrow key shortcuts
- Tests cover every deck, difficulty, and font glyph coverage

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/assets/assets.odin

@@ -2,28 +2,57 @@ package assets
 
 import raylib "vendor:raylib"
 
-REGULAR_FONT_PATH :: "assets/MPLUSRounded1c-Medium.ttf"
-BOLD_FONT_PATH    :: "assets/MPLUSRounded1c-ExtraBold.ttf"
-
 // Glyphs are rasterized at this size and scaled down when drawn
 FONT_BASE_SIZE :: 128
 
-regular_font: raylib.Font
-bold_font: raylib.Font
+Font_Style :: enum {
+    REGULAR, // UI text (M PLUS Rounded 1c Medium)
+    BOLD,    // UI headings and Japanese symbols (M PLUS Rounded 1c ExtraBold)
+    KOREAN,  // Hangul (Jua)
+    THAI,    // Thai script (Mali SemiBold)
+}
 
-// raylib only bakes ASCII by default, so every non-ASCII glyph must be listed
-@(private)
-build_codepoints :: proc() -> [dynamic]rune {
-    codepoints: [dynamic]rune
-    for r in rune(0x20) ..= 0x7E { append(&codepoints, r) }     // ASCII
-    for r in rune(0x3041) ..= 0x3096 { append(&codepoints, r) } // Hiragana
-    for r in rune(0x30A1) ..= 0x30FC { append(&codepoints, r) } // Katakana
-    for r in "日本語・·āō" { append(&codepoints, r) }
+@(rodata)
+FONT_PATHS := [Font_Style]cstring{
+    .REGULAR = "assets/MPLUSRounded1c-Medium.ttf",
+    .BOLD    = "assets/MPLUSRounded1c-ExtraBold.ttf",
+    .KOREAN  = "assets/Jua-Regular.ttf",
+    .THAI    = "assets/Mali-SemiBold.ttf",
+}
+
+fonts: [Font_Style]raylib.Font
+
+// Extra non-range characters used in UI text
+EXTRA_JAPANESE :: "日本語・·āō"
+EXTRA_KOREAN   :: "한글국어축하해요"
+EXTRA_THAI     :: "ไทย"
+
+// raylib only bakes the codepoints it is given, so every glyph a font must draw is listed here.
+// Tests check that every deck's characters are covered.
+codepoints_for :: proc(style: Font_Style, allocator := context.allocator) -> [dynamic]rune {
+    codepoints := make([dynamic]rune, allocator)
+    for r in rune(0x20) ..= 0x7E { append(&codepoints, r) } // ASCII
+    switch style {
+    case .REGULAR, .BOLD:
+        for r in rune(0x3041) ..= 0x3096 { append(&codepoints, r) } // Hiragana
+        for r in rune(0x30A1) ..= 0x30FC { append(&codepoints, r) } // Katakana
+        for r in EXTRA_JAPANESE { append(&codepoints, r) }
+    case .KOREAN:
+        for r in rune(0x3131) ..= 0x3163 { append(&codepoints, r) } // Modern Hangul compatibility jamo
+        for r in EXTRA_KOREAN { append(&codepoints, r) }
+    case .THAI:
+        for r in rune(0x0E01) ..= 0x0E3A { append(&codepoints, r) } // Thai (U+0E3B-0E3E are unassigned)
+        for r in rune(0x0E3F) ..= 0x0E5B { append(&codepoints, r) }
+        for r in EXTRA_THAI { append(&codepoints, r) }
+    }
     return codepoints
 }
 
 @(private)
-load_font :: proc(path: cstring, codepoints: []rune) -> raylib.Font {
+load_font :: proc(style: Font_Style) -> raylib.Font {
+    codepoints := codepoints_for(style)
+    defer delete(codepoints)
+    path := FONT_PATHS[style]
     font := raylib.LoadFontEx(path, FONT_BASE_SIZE, raw_data(codepoints), i32(len(codepoints)))
     if !raylib.IsFontValid(font) || font.texture.id == 0 {
         raylib.TraceLog(.WARNING, "ASSETS: Falling back to default font, could not load %s", path)
@@ -36,18 +65,18 @@ load_font :: proc(path: cstring, codepoints: []rune) -> raylib.Font {
 }
 
 load_fonts :: proc() {
-    codepoints := build_codepoints()
-    defer delete(codepoints)
-    regular_font = load_font(REGULAR_FONT_PATH, codepoints[:])
-    bold_font = load_font(BOLD_FONT_PATH, codepoints[:])
+    for style in Font_Style {
+        fonts[style] = load_font(style)
+    }
 }
 
 unload_fonts :: proc() {
     default_id := raylib.GetFontDefault().texture.id
-    if regular_font.texture.id != default_id { raylib.UnloadFont(regular_font) }
-    if bold_font.texture.id != default_id { raylib.UnloadFont(bold_font) }
+    for font in fonts {
+        if font.texture.id != default_id { raylib.UnloadFont(font) }
+    }
 }
 
-get_font :: proc(bold := false) -> raylib.Font {
-    return bold ? bold_font : regular_font
+get_font :: proc(style: Font_Style = .REGULAR) -> raylib.Font {
+    return fonts[style]
 }

src/card/card.odin

@@ -2,6 +2,7 @@ package card
 
 import "core:math"
 import raylib "vendor:raylib"
+import assets "../assets"
 import themes "../themes"
 import ui "../ui"
 
@@ -19,8 +20,9 @@ HOVER_LIFT     :: 4
 
 Card :: struct {
     rect:     raylib.Rectangle, // resting position on screen
-    text:     cstring,
-    is_kana:  bool,
+    text:      cstring,
+    hint:      cstring, // small second line on reading cards
+    is_symbol: bool,    // script symbol (vs. its reading)
     pair_id:  int,
     face_up:  bool, // logical state; the animation follows it
     matched:  bool,
@@ -154,21 +156,34 @@ get_back_art :: proc(flag: themes.Flag) -> raylib.Texture2D {
     return back_art[flag].texture
 }
 
-// Renders the card's face into its own texture
-build_face :: proc(card: ^Card, theme: themes.Theme) {
+// Font size that fits text inside the card width
+@(private)
+fit_size :: proc(text: cstring, size: f32, style: assets.Font_Style) -> f32 {
+    max_width: f32 = ART_WIDTH * 0.78
+    width := ui.measure_text(text, size, style).x
+    return width > max_width ? size * max_width / width : size
+}
+
+// Renders the card's face into its own texture. Symbols use their script's font.
+build_face :: proc(card: ^Card, theme: themes.Theme, symbol_style: assets.Font_Style) {
     unload_face(card)
     card.face_art = new_art_texture(theme.primary)
     raylib.BeginTextureMode(card.face_art)
     draw_frame(theme.card_face, theme.primary)
     raylib.DrawRectangleRoundedLinesEx(art_rect(16), ROUNDNESS, SEGMENTS, 2, raylib.Fade(theme.primary, 0.35))
 
-    size: f32 = card.is_kana ? 132 : 96
-    color := card.is_kana ? theme.ink : theme.primary
-    // Shrink long romaji (e.g. "TSU") to fit inside the card
-    max_width: f32 = ART_WIDTH * 0.78
-    width := ui.measure_text(card.text, size, bold = true).x
-    if width > max_width { size *= max_width / width }
-    ui.draw_text_in_rect(card.text, art_rect(), size, color, bold = true)
+    if card.is_symbol {
+        ui.draw_text_in_rect(card.text, art_rect(), fit_size(card.text, 132, symbol_style), theme.ink, symbol_style)
+    } else if card.hint == nil {
+        ui.draw_text_in_rect(card.text, art_rect(), fit_size(card.text, 96, .BOLD), theme.primary, .BOLD)
+    } else {
+        // Reading on top, hint underneath
+        main_rect := art_rect()
+        main_rect.height -= 56
+        ui.draw_text_in_rect(card.text, main_rect, fit_size(card.text, 88, .BOLD), theme.primary, .BOLD)
+        hint_rect := raylib.Rectangle{0, ART_HEIGHT * 0.62, ART_WIDTH, 60}
+        ui.draw_text_in_rect(card.hint, hint_rect, fit_size(card.hint, 34, .REGULAR), theme.ink, .REGULAR)
+    }
     raylib.EndTextureMode()
 }
 

src/decks/decks.odin

@@ -0,0 +1,141 @@
+package decks
+
+import assets "../assets"
+import themes "../themes"
+
+Language :: enum {
+    JAPANESE,
+    KOREAN,
+    THAI,
+}
+
+Deck_Id :: enum {
+    HIRAGANA,
+    KATAKANA,
+    HANGUL,
+    THAI_CONSONANTS,
+}
+
+// One card pair: the script symbol and how it reads
+Entry :: struct {
+    symbol:  cstring,
+    reading: cstring, // romanization, shown large
+    hint:    cstring, // optional small line under the reading
+}
+
+Deck_Info :: struct {
+    name:     cstring, // English name, used on buttons
+    native:   cstring, // name in its own script
+    language: Language,
+}
+
+Language_Info :: struct {
+    theme:          themes.Theme,
+    native:         cstring,           // language name in its own script
+    symbol_style:   assets.Font_Style, // font for the script's symbols
+    congrats:       cstring,           // win message
+    congrats_style: assets.Font_Style,
+}
+
+@(rodata)
+DECKS := [Deck_Id]Deck_Info{
+    .HIRAGANA        = {name = "Hiragana", native = "ひらがな", language = .JAPANESE},
+    .KATAKANA        = {name = "Katakana", native = "カタカナ", language = .JAPANESE},
+    .HANGUL          = {name = "Hangul", native = "한글", language = .KOREAN},
+    .THAI_CONSONANTS = {name = "Consonants", native = "ก ข ค", language = .THAI},
+}
+
+@(rodata)
+LANGUAGES := [Language]Language_Info{
+    .JAPANESE = {theme = themes.JAPAN, native = "日本語", symbol_style = .BOLD, congrats = "おめでとう!", congrats_style = .BOLD},
+    .KOREAN   = {theme = themes.KOREA, native = "한국어", symbol_style = .KOREAN, congrats = "축하해요!", congrats_style = .KOREAN},
+    // Thai words with vowel/tone marks need text shaping, which raylib doesn't do
+    .THAI     = {theme = themes.THAI, native = "ไทย", symbol_style = .THAI, congrats = "Well done!", congrats_style = .BOLD},
+}
+
+@(private, rodata)
+japanese_decks := [?]Deck_Id{.HIRAGANA, .KATAKANA}
+@(private, rodata)
+korean_decks := [?]Deck_Id{.HANGUL}
+@(private, rodata)
+thai_decks := [?]Deck_Id{.THAI_CONSONANTS}
+
+decks_for :: proc(language: Language) -> []Deck_Id {
+    switch language {
+    case .JAPANESE: return japanese_decks[:]
+    case .KOREAN:   return korean_decks[:]
+    case .THAI:     return thai_decks[:]
+    }
+    return nil
+}
+
+language_of :: proc(deck: Deck_Id) -> Language_Info {
+    return LANGUAGES[DECKS[deck].language]
+}
+
+entries :: proc(deck: Deck_Id) -> []Entry {
+    switch deck {
+    case .HIRAGANA:        return hiragana[:]
+    case .KATAKANA:        return katakana[:]
+    case .HANGUL:          return hangul[:]
+    case .THAI_CONSONANTS: return thai_consonants[:]
+    }
+    return nil
+}
+
+// The 46 basic hiragana (gojūon)
+@(private, rodata)
+hiragana := [?]Entry{
+    {"あ", "a", nil}, {"い", "i", nil}, {"う", "u", nil}, {"え", "e", nil}, {"お", "o", nil},
+    {"か", "ka", nil}, {"き", "ki", nil}, {"く", "ku", nil}, {"け", "ke", nil}, {"こ", "ko", nil},
+    {"さ", "sa", nil}, {"し", "shi", nil}, {"す", "su", nil}, {"せ", "se", nil}, {"そ", "so", nil},
+    {"た", "ta", nil}, {"ち", "chi", nil}, {"つ", "tsu", nil}, {"て", "te", nil}, {"と", "to", nil},
+    {"な", "na", nil}, {"に", "ni", nil}, {"ぬ", "nu", nil}, {"ね", "ne", nil}, {"の", "no", nil},
+    {"は", "ha", nil}, {"ひ", "hi", nil}, {"ふ", "fu", nil}, {"へ", "he", nil}, {"ほ", "ho", nil},
+    {"ま", "ma", nil}, {"み", "mi", nil}, {"む", "mu", nil}, {"め", "me", nil}, {"も", "mo", nil},
+    {"や", "ya", nil}, {"ゆ", "yu", nil}, {"よ", "yo", nil},
+    {"ら", "ra", nil}, {"り", "ri", nil}, {"る", "ru", nil}, {"れ", "re", nil}, {"ろ", "ro", nil},
+    {"わ", "wa", nil}, {"を", "wo", nil}, {"ん", "n", nil},
+}
+
+// The 46 basic katakana
+@(private, rodata)
+katakana := [?]Entry{
+    {"ア", "a", nil}, {"イ", "i", nil}, {"ウ", "u", nil}, {"エ", "e", nil}, {"オ", "o", nil},
+    {"カ", "ka", nil}, {"キ", "ki", nil}, {"ク", "ku", nil}, {"ケ", "ke", nil}, {"コ", "ko", nil},
+    {"サ", "sa", nil}, {"シ", "shi", nil}, {"ス", "su", nil}, {"セ", "se", nil}, {"ソ", "so", nil},
+    {"タ", "ta", nil}, {"チ", "chi", nil}, {"ツ", "tsu", nil}, {"テ", "te", nil}, {"ト", "to", nil},
+    {"ナ", "na", nil}, {"ニ", "ni", nil}, {"ヌ", "nu", nil}, {"ネ", "ne", nil}, {"ノ", "no", nil},
+    {"ハ", "ha", nil}, {"ヒ", "hi", nil}, {"フ", "fu", nil}, {"ヘ", "he", nil}, {"ホ", "ho", nil},
+    {"マ", "ma", nil}, {"ミ", "mi", nil}, {"ム", "mu", nil}, {"メ", "me", nil}, {"モ", "mo", nil},
+    {"ヤ", "ya", nil}, {"ユ", "yu", nil}, {"ヨ", "yo", nil},
+    {"ラ", "ra", nil}, {"リ", "ri", nil}, {"ル", "ru", nil}, {"レ", "re", nil}, {"ロ", "ro", nil},
+    {"ワ", "wa", nil}, {"ヲ", "wo", nil}, {"ン", "n", nil},
+}
+
+// The 14 basic consonants and 10 basic vowels, Revised Romanization (initial position)
+@(private, rodata)
+hangul := [?]Entry{
+    {"ㄱ", "g", nil}, {"ㄴ", "n", nil}, {"ㄷ", "d", nil}, {"ㄹ", "r", nil}, {"ㅁ", "m", nil},
+    {"ㅂ", "b", nil}, {"ㅅ", "s", nil}, {"ㅇ", "ng", "silent first"}, {"ㅈ", "j", nil}, {"ㅊ", "ch", nil},
+    {"ㅋ", "k", nil}, {"ㅌ", "t", nil}, {"ㅍ", "p", nil}, {"ㅎ", "h", nil},
+    {"ㅏ", "a", nil}, {"ㅑ", "ya", nil}, {"ㅓ", "eo", nil}, {"ㅕ", "yeo", nil}, {"ㅗ", "o", nil},
+    {"ㅛ", "yo", nil}, {"ㅜ", "u", nil}, {"ㅠ", "yu", nil}, {"ㅡ", "eu", nil}, {"ㅣ", "i", nil},
+}
+
+// The 42 Thai consonants in use (ฃ and ฅ are obsolete). Many share a sound, so the
+// hint is each letter's acrophonic name word (RTGS), which is unique.
+@(private, rodata)
+thai_consonants := [?]Entry{
+    {"ก", "k", "kai"}, {"ข", "kh", "khai"}, {"ค", "kh", "khwai"}, {"ฆ", "kh", "rakhang"},
+    {"ง", "ng", "ngu"}, {"จ", "ch", "chan"}, {"ฉ", "ch", "ching"}, {"ช", "ch", "chang"},
+    {"ซ", "s", "so"}, {"ฌ", "ch", "choe"}, {"ญ", "y", "ying"}, {"ฎ", "d", "chada"},
+    {"ฏ", "t", "patak"}, {"ฐ", "th", "than"}, {"ฑ", "th", "montho"}, {"ฒ", "th", "phuthao"},
+    {"ณ", "n", "nen"}, {"ด", "d", "dek"}, {"ต", "t", "tao"}, {"ถ", "th", "thung"},
+    {"ท", "th", "thahan"}, {"ธ", "th", "thong"}, {"น", "n", "nu"}, {"บ", "b", "baimai"},
+    {"ป", "p", "pla"}, {"ผ", "ph", "phueng"}, {"ฝ", "f", "fa"}, {"พ", "ph", "phan"},
+    {"ฟ", "f", "fan"}, {"ภ", "ph", "samphao"}, {"ม", "m", "ma"}, {"ย", "y", "yak"},
+    {"ร", "r", "ruea"}, {"ล", "l", "ling"}, {"ว", "w", "waen"}, {"ศ", "s", "sala"},
+    {"ษ", "s", "ruesi"}, {"ส", "s", "suea"}, {"ห", "h", "hip"}, {"ฬ", "l", "chula"},
+    {"อ", "o", "ang"}, {"ฮ", "h", "nokhuk"},
+}

src/memory/memory.odin

@@ -4,44 +4,50 @@ import "core:math/rand"
 import raylib "vendor:raylib"
 import audio "../audio"
 import card "../card"
+import decks "../decks"
 import themes "../themes"
 import ui "../ui"
 
-PAIR_COUNT :: 12
-CARD_COUNT :: PAIR_COUNT * 2
+MAX_CARDS :: 32
 
 MATCH_DELAY    :: 0.35 // seconds both cards stay up before a match is confirmed
 MISMATCH_DELAY :: 0.9  // seconds before a wrong pair flips back
 
+Difficulty :: enum {
+    EASY,
+    NORMAL,
+    HARD,
+}
+
+Layout :: struct {
+    rows, cols: int,
+}
+
+@(rodata)
+LAYOUTS := [Difficulty]Layout{
+    .EASY   = {3, 4},
+    .NORMAL = {4, 6},
+    .HARD   = {4, 8},
+}
+
+@(rodata)
+DIFFICULTY_NAMES := [Difficulty]cstring{.EASY = "Easy", .NORMAL = "Normal", .HARD = "Hard"}
+
 State :: enum {
-    WAITING,  // no card selected
-    FIRST,    // one card selected
+    WAITING,   // no card selected
+    FIRST,     // one card selected
     RESOLVING, // two cards up, waiting before match/mismatch
     OVER,
 }
 
-Kana :: struct {
-    kana:   cstring,
-    romaji: cstring,
-}
-
-// The 46 basic hiragana (gojūon)
-HIRAGANA :: [?]Kana{
-    {"あ", "a"}, {"い", "i"}, {"う", "u"}, {"え", "e"}, {"お", "o"},
-    {"か", "ka"}, {"き", "ki"}, {"く", "ku"}, {"け", "ke"}, {"こ", "ko"},
-    {"さ", "sa"}, {"し", "shi"}, {"す", "su"}, {"せ", "se"}, {"そ", "so"},
-    {"た", "ta"}, {"ち", "chi"}, {"つ", "tsu"}, {"て", "te"}, {"と", "to"},
-    {"な", "na"}, {"に", "ni"}, {"ぬ", "nu"}, {"ね", "ne"}, {"の", "no"},
-    {"は", "ha"}, {"ひ", "hi"}, {"ふ", "fu"}, {"へ", "he"}, {"ほ", "ho"},
-    {"ま", "ma"}, {"み", "mi"}, {"む", "mu"}, {"め", "me"}, {"も", "mo"},
-    {"や", "ya"}, {"ゆ", "yu"}, {"よ", "yo"},
-    {"ら", "ra"}, {"り", "ri"}, {"る", "ru"}, {"れ", "re"}, {"ろ", "ro"},
-    {"わ", "wa"}, {"を", "wo"}, {"ん", "n"},
-}
-
-cards: [CARD_COUNT]card.Card
-state: State
+cards: [MAX_CARDS]card.Card
+card_count: int
+pair_count: int
+deck: decks.Deck_Id
+difficulty: Difficulty
 theme: themes.Theme
+layout: Layout
+state: State
 first: int = -1
 second: int = -1
 matches: int
@@ -52,33 +58,46 @@ win_t: f32 // fades in the win panel
 restart_requested: bool
 
 // Deals a new game and renders the card faces. Needs the window to exist.
-start :: proc(game_theme: themes.Theme) {
-    deal(game_theme)
-    for &c in cards { card.build_face(&c, theme) }
+start :: proc(deck_id: decks.Deck_Id, game_difficulty: Difficulty) {
+    deal(deck_id, game_difficulty)
+    style := decks.language_of(deck).symbol_style
+    for &c in active_cards() { card.build_face(&c, theme, style) }
 }
 
 // Shuffles, lays out and resets the game state without touching the GPU
-deal :: proc(game_theme: themes.Theme) {
-    theme = game_theme
+deal :: proc(deck_id: decks.Deck_Id, game_difficulty: Difficulty) {
+    unload()
+    deck = deck_id
+    difficulty = game_difficulty
+    theme = decks.language_of(deck).theme
+    layout = LAYOUTS[difficulty]
+    card_count = layout.rows * layout.cols
+    pair_count = card_count / 2
 
-    deck := HIRAGANA
-    rand.shuffle(deck[:])
-    for i in 0 ..< PAIR_COUNT {
-        card.unload_face(&cards[i * 2])
-        card.unload_face(&cards[i * 2 + 1])
-        cards[i * 2] = card.Card{text = deck[i].kana, is_kana = true, pair_id = i}
-        cards[i * 2 + 1] = card.Card{text = deck[i].romaji, is_kana = false, pair_id = i}
+    // Pick random entries from the deck
+    entries := decks.entries(deck)
+    order := make([]int, len(entries), context.temp_allocator)
+    for &o, i in order { o = i }
+    rand.shuffle(order)
+
+    for pair in 0 ..< pair_count {
+        entry := entries[order[pair]]
+        cards[pair * 2] = card.Card{text = entry.symbol, is_symbol = true, pair_id = pair}
+        cards[pair * 2 + 1] = card.Card{text = entry.reading, hint = entry.hint, pair_id = pair}
     }
-    rand.shuffle(cards[:])
+    rand.shuffle(cards[:card_count])
 
-    total_w: f32 = themes.GRID_COLS * (themes.CARD_WIDTH + themes.CARD_SPACING) - themes.CARD_SPACING
+    // Center the grid horizontally and in the space below the header
+    step_x: f32 = themes.CARD_WIDTH + themes.CARD_SPACING
+    step_y: f32 = themes.CARD_HEIGHT + themes.CARD_SPACING
+    total_w := f32(layout.cols) * step_x - themes.CARD_SPACING
+    total_h := f32(layout.rows) * step_y - themes.CARD_SPACING
     start_x := (themes.SCREEN_WIDTH - total_w) / 2
-    for &c, i in cards {
-        row := f32(i / themes.GRID_COLS)
-        col := f32(i % themes.GRID_COLS)
+    start_y := themes.GRID_TOP + (themes.SCREEN_HEIGHT - 16 - themes.GRID_TOP - total_h) / 2
+    for &c, i in active_cards() {
         c.rect = {
-            start_x + col * (themes.CARD_WIDTH + themes.CARD_SPACING),
-            themes.GRID_TOP + row * (themes.CARD_HEIGHT + themes.CARD_SPACING),
+            start_x + f32(i % layout.cols) * step_x,
+            start_y + f32(i / layout.cols) * step_y,
             themes.CARD_WIDTH,
             themes.CARD_HEIGHT,
         }
@@ -95,11 +114,16 @@ deal :: proc(game_theme: themes.Theme) {
     restart_requested = false
 }
 
+active_cards :: proc() -> []card.Card {
+    return cards[:card_count]
+}
+
 unload :: proc() {
     for &c in cards { card.unload_face(&c) }
 }
 
 can_pick :: proc(i: int) -> bool {
+    if i < 0 || i >= card_count { return false }
     c := &cards[i]
     return (state == .WAITING || state == .FIRST) && !c.face_up && !c.matched
 }
@@ -131,7 +155,7 @@ resolve :: proc() {
         card.start_pulse(a)
         card.start_pulse(b)
         matches += 1
-        if matches == PAIR_COUNT {
+        if matches == pair_count {
             state = .OVER
             audio.play(.WIN)
         } else {
@@ -151,17 +175,17 @@ resolve :: proc() {
 
 update :: proc(dt: f32) {
     if restart_requested {
-        start(theme)
+        start(deck, difficulty)
         return
     }
 
-    for &c in cards { card.update(&c, dt) }
+    for &c in active_cards() { card.update(&c, dt) }
 
     switch state {
     case .WAITING, .FIRST:
         elapsed += dt
         if raylib.IsMouseButtonPressed(.LEFT) {
-            for &c, i in cards {
+            for &c, i in active_cards() {
                 if card.is_hovered(&c) && select_card(i) {
                     break
                 }
@@ -181,20 +205,22 @@ update :: proc(dt: f32) {
 
 // Draws the game and returns the screen to show next frame
 draw :: proc() -> themes.Screen {
-    next := themes.Screen.JAPANESE_MEMORY
+    next := themes.Screen.MEMORY
     raylib.ClearBackground(theme.background)
 
-    ui.draw_title("Hiragana Memory", 24, theme.primary, 48)
+    info := decks.DECKS[deck]
+    ui.draw_title(raylib.TextFormat("%s · %s", theme.name, info.name), 24, theme.primary, 48)
     minutes := int(elapsed) / 60
     seconds := int(elapsed) % 60
-    info := raylib.TextFormat("Moves %d   ·   Pairs %d/%d   ·   %d:%02d", moves, matches, PAIR_COUNT, minutes, seconds)
-    ui.draw_text_centered(info, themes.SCREEN_WIDTH / 2, 88, 24, theme.ink)
+    stats := raylib.TextFormat("%s   ·   Moves %d   ·   Pairs %d/%d   ·   %d:%02d",
+                               DIFFICULTY_NAMES[difficulty], moves, matches, pair_count, minutes, seconds)
+    ui.draw_text_centered(stats, themes.SCREEN_WIDTH / 2, 88, 24, theme.ink)
 
     if state != .OVER && ui.button({30, 28, 120, 48}, "Back", theme.primary, font_size = 22) {
-        next = .JAPANESE_MENU
+        next = .LANGUAGE_MENU
     }
 
-    for &c, i in cards {
+    for &c, i in active_cards() {
         card.draw(&c, theme, can_pick(i))
     }
 
@@ -218,13 +244,14 @@ draw_win_panel :: proc() -> Maybe(themes.Screen) {
     raylib.DrawRectangleRounded(panel, 0.12, 16, raylib.Fade(theme.card_face, win_t))
     raylib.DrawRectangleRoundedLinesEx(panel, 0.12, 16, 4, raylib.Fade(theme.primary, win_t))
 
+    language := decks.language_of(deck)
     cx := panel.x + panel_w / 2
-    ui.draw_text_centered("おめでとう!", cx, panel.y + 34, 56, raylib.Fade(theme.primary, win_t), bold = true)
-    ui.draw_text_centered("Congratulations, all pairs found!", cx, panel.y + 112, 26, raylib.Fade(theme.ink, win_t))
+    ui.draw_text_centered(language.congrats, cx, panel.y + 34, 56, raylib.Fade(theme.primary, win_t), language.congrats_style)
+    ui.draw_text_centered("All pairs found!", cx, panel.y + 112, 26, raylib.Fade(theme.ink, win_t))
     minutes := int(elapsed) / 60
     seconds := int(elapsed) % 60
     stats := raylib.TextFormat("%d moves  ·  %d:%02d", moves, minutes, seconds)
-    ui.draw_text_centered(stats, cx, panel.y + 156, 26, raylib.Fade(theme.ink, win_t), bold = true)
+    ui.draw_text_centered(stats, cx, panel.y + 156, 26, raylib.Fade(theme.ink, win_t), .BOLD)
 
     if win_t < 1 { return nil }
     button_w: f32 = 200
@@ -233,7 +260,7 @@ draw_win_panel :: proc() -> Maybe(themes.Screen) {
         restart_requested = true
     }
     if ui.button({cx + 10, button_y, button_w, 60}, "Menu", theme.ink) {
-        return .JAPANESE_MENU
+        return .LANGUAGE_MENU
     }
     return nil
 }

src/screens/screens.odin

@@ -3,15 +3,11 @@ package screens
 import "core:math"
 import raylib "vendor:raylib"
 import card "../card"
+import decks "../decks"
+import memory "../memory"
 import themes "../themes"
 import ui "../ui"
 
-LANGUAGES :: [3]struct{ theme: themes.Theme, screen: themes.Screen }{
-    {themes.JAPAN, .JAPANESE_MENU},
-    {themes.KOREA, .KOREAN_MENU},
-    {themes.THAI, .THAI_MENU},
-}
-
 // Draws a card back like a playing card lying on the table
 @(private)
 draw_card_art :: proc(flag: themes.Flag, rect: raylib.Rectangle, rotation: f32 = 0) {
@@ -26,13 +22,18 @@ draw_card_art :: proc(flag: themes.Flag, rect: raylib.Rectangle, rotation: f32 =
     raylib.DrawTexturePro(texture, source, dest, origin, rotation, themes.WHITE)
 }
 
-main_menu :: proc() -> themes.Screen {
-    next := themes.Screen.MAIN_MENU
+@(private)
+NUMBER_KEYS :: [?]raylib.KeyboardKey{.ONE, .TWO, .THREE, .FOUR, .FIVE}
+
+// Returns the language picked this frame, if any
+main_menu :: proc() -> Maybe(decks.Language) {
     raylib.ClearBackground(themes.MENU_BACKGROUND)
+    languages := decks.LANGUAGES
+    keys := NUMBER_KEYS
 
     // Thin stripes along the top in each language's primary color
-    stripe_w: i32 = themes.SCREEN_WIDTH / 3
-    for lang, i in LANGUAGES {
+    stripe_w: i32 = themes.SCREEN_WIDTH / len(decks.Language)
+    for lang, i in languages {
         raylib.DrawRectangle(i32(i) * stripe_w, 0, stripe_w, 8, lang.theme.primary)
     }
 
@@ -46,66 +47,88 @@ main_menu :: proc() -> themes.Screen {
     start_x := (themes.SCREEN_WIDTH - total) / 2
     // Gentle bobbing so the menu feels alive
     time := f32(raylib.GetTime())
-    for lang, i in LANGUAGES {
+    picked: Maybe(decks.Language)
+    for lang, language in languages {
+        i := int(language)
         x := start_x + f32(i) * (tile_w + gap)
         bob := math.sin(time * 1.6 + f32(i) * 1.1) * 4
         rotation := f32(i - 1) * 4
         draw_card_art(lang.theme.flag, {x, 250 + bob, tile_w, tile_h}, rotation)
-        button_rect := raylib.Rectangle{x + tile_w / 2 - themes.BUTTON_WIDTH / 2 + 30, 500, themes.BUTTON_WIDTH - 60, themes.BUTTON_HEIGHT}
-        if ui.button(button_rect, lang.theme.name, lang.theme.primary) {
-            next = lang.screen
+        button_rect := raylib.Rectangle{x + tile_w / 2 - (themes.BUTTON_WIDTH - 60) / 2, 500, themes.BUTTON_WIDTH - 60, themes.BUTTON_HEIGHT}
+        if ui.button(button_rect, lang.theme.name, lang.theme.primary, hotkey = keys[i]) {
+            picked = language
         }
     }
 
-    ui.draw_text_centered("Esc to go back  ·  Esc on this screen quits", themes.SCREEN_WIDTH / 2, 660, 18, raylib.Fade(themes.DARK_GRAY, 0.7))
-    return next
+    ui.draw_text_centered("1-3 pick a language  ·  Esc goes back, and quits from here", themes.SCREEN_WIDTH / 2, 660, 18, raylib.Fade(themes.DARK_GRAY, 0.8))
+    return picked
 }
 
-// Shared layout for a language's menu screen. Returns the clicked option index, -1 for back, or nil.
-@(private)
-language_menu :: proc(theme: themes.Theme, subtitle: cstring, options: []cstring) -> Maybe(int) {
+Language_Menu_Result :: union {
+    decks.Deck_Id, // start a game with this deck
+    themes.Screen, // go to another screen
+}
+
+// A language's menu: pick a deck and a difficulty
+language_menu :: proc(language: decks.Language, difficulty: ^memory.Difficulty) -> Language_Menu_Result {
+    info := decks.LANGUAGES[language]
+    theme := info.theme
+    keys := NUMBER_KEYS
     raylib.ClearBackground(theme.background)
     raylib.DrawRectangle(0, 0, themes.SCREEN_WIDTH, 8, theme.primary)
 
-    ui.draw_title(theme.name, 70, theme.primary)
-    ui.draw_text_centered(subtitle, themes.SCREEN_WIDTH / 2, 170, themes.SUBTITLE_FONT_SIZE, theme.ink)
+    ui.draw_title(theme.name, 50, theme.primary)
+    ui.draw_text_centered(info.native, themes.SCREEN_WIDTH / 2, 140, 30, theme.ink, info.symbol_style)
 
     // A small fan of card backs
     for i in 0 ..< 3 {
         offset := f32(i - 1)
-        draw_card_art(theme.flag, {themes.SCREEN_WIDTH / 2 - 55 + offset * 70, 235 + abs(offset) * 10, 110, 146}, offset * 9)
+        draw_card_art(theme.flag, {themes.SCREEN_WIDTH / 2 - 50 + offset * 64, 195 + abs(offset) * 10, 100, 133}, offset * 9)
     }
 
-    result: Maybe(int)
-    y: f32 = 440
-    for option, i in options {
-        if ui.button({(themes.SCREEN_WIDTH - themes.BUTTON_WIDTH) / 2, y, themes.BUTTON_WIDTH, themes.BUTTON_HEIGHT}, option, theme.primary) {
-            result = i
+    result: Language_Menu_Result
+
+    // One button per deck
+    deck_list := decks.decks_for(language)
+    button_w: f32 = 220
+    gap: f32 = 24
+    total := f32(len(deck_list)) * button_w + f32(len(deck_list) - 1) * gap
+    x := (themes.SCREEN_WIDTH - total) / 2
+    for deck, i in deck_list {
+        rect := raylib.Rectangle{x, 380, button_w, themes.BUTTON_HEIGHT}
+        if ui.button(rect, decks.DECKS[deck].name, theme.primary, hotkey = keys[i]) {
+            result = deck
         }
-        y += themes.BUTTON_HEIGHT + 20
+        ui.draw_text_centered(decks.DECKS[deck].native, x + button_w / 2, 450, 22, theme.ink, info.symbol_style)
+        x += button_w + gap
     }
-    if ui.button({(themes.SCREEN_WIDTH - themes.BUTTON_WIDTH) / 2, y, themes.BUTTON_WIDTH, themes.BUTTON_HEIGHT}, "Back", theme.ink) {
-        result = -1
+
+    // Difficulty selector
+    names := memory.DIFFICULTY_NAMES
+    layouts := memory.LAYOUTS
+    ui.draw_text_centered("Difficulty  (Left / Right)", themes.SCREEN_WIDTH / 2, 500, 20, raylib.Fade(theme.ink, 0.7))
+    seg_w: f32 = 150
+    seg_x := (themes.SCREEN_WIDTH - 3 * seg_w - 2 * 12) / 2
+    for level in memory.Difficulty {
+        selected := difficulty^ == level
+        color := selected ? theme.primary : raylib.ColorLerp(theme.primary, themes.WHITE, 0.55)
+        label := raylib.TextFormat("%s  %d", names[level], layouts[level].rows * layouts[level].cols / 2)
+        if ui.button({seg_x, 530, seg_w, 48}, label, color, font_size = 22, selected = selected) {
+            difficulty^ = level
+        }
+        seg_x += seg_w + 12
     }
+    if raylib.IsKeyPressed(.LEFT) && difficulty^ > .EASY {
+        difficulty^ = memory.Difficulty(int(difficulty^) - 1)
+    }
+    if raylib.IsKeyPressed(.RIGHT) && difficulty^ < .HARD {
+        difficulty^ = memory.Difficulty(int(difficulty^) + 1)
+    }
+
+    if ui.button({30, 28, 120, 48}, "Back", theme.ink, font_size = 22) {
+        result = themes.Screen.MAIN_MENU
+    }
+    hint := len(deck_list) > 1 ? cstring("1-2 pick a deck  ·  Left / Right difficulty  ·  Esc back") : cstring("1 start  ·  Left / Right difficulty  ·  Esc back")
+    ui.draw_text_centered(hint, themes.SCREEN_WIDTH / 2, 660, 18, raylib.Fade(theme.ink, 0.6))
     return result
 }
-
-japanese_menu :: proc() -> themes.Screen {
-    choice, clicked := language_menu(themes.JAPAN, "ひらがな · Hiragana", {"Memory Game"}).?
-    if !clicked { return .JAPANESE_MENU }
-    return choice == 0 ? .JAPANESE_MEMORY : .MAIN_MENU
-}
-
-korean_menu :: proc() -> themes.Screen {
-    if _, clicked := language_menu(themes.KOREA, "Hangul · coming soon", {}).?; clicked {
-        return .MAIN_MENU
-    }
-    return .KOREAN_MENU
-}
-
-thai_menu :: proc() -> themes.Screen {
-    if _, clicked := language_menu(themes.THAI, "Thai script · coming soon", {}).?; clicked {
-        return .MAIN_MENU
-    }
-    return .THAI_MENU
-}

src/themes/themes.odin

@@ -7,10 +7,8 @@ SCREEN_HEIGHT :: 720
 
 Screen :: enum {
     MAIN_MENU,
-    JAPANESE_MENU,
-    JAPANESE_MEMORY,
-    KOREAN_MENU,
-    THAI_MENU,
+    LANGUAGE_MENU,
+    MEMORY,
 }
 
 // Which national flag the card backs are modelled on
@@ -88,5 +86,3 @@ CARD_WIDTH   :: 96
 CARD_HEIGHT  :: 128
 CARD_SPACING :: 14
 GRID_TOP     :: 136
-GRID_ROWS    :: 4
-GRID_COLS    :: 6

src/ui/ui.odin

@@ -5,6 +5,8 @@ import assets "../assets"
 import audio "../audio"
 import themes "../themes"
 
+Font_Style :: assets.Font_Style
+
 TEXT_SPACING :: 1
 
 @(private)
@@ -25,38 +27,42 @@ set_hovered :: proc() {
     any_hovered = true
 }
 
-measure_text :: proc(text: cstring, size: f32, bold := false) -> raylib.Vector2 {
-    return raylib.MeasureTextEx(assets.get_font(bold), text, size, TEXT_SPACING)
+measure_text :: proc(text: cstring, size: f32, style: Font_Style = .REGULAR) -> raylib.Vector2 {
+    return raylib.MeasureTextEx(assets.get_font(style), text, size, TEXT_SPACING)
 }
 
-draw_text :: proc(text: cstring, pos: raylib.Vector2, size: f32, color: raylib.Color, bold := false) {
-    raylib.DrawTextEx(assets.get_font(bold), text, pos, size, TEXT_SPACING, color)
+draw_text :: proc(text: cstring, pos: raylib.Vector2, size: f32, color: raylib.Color, style: Font_Style = .REGULAR) {
+    raylib.DrawTextEx(assets.get_font(style), text, pos, size, TEXT_SPACING, color)
 }
 
 // Draws text horizontally centered on center_x with its top at y
-draw_text_centered :: proc(text: cstring, center_x, y, size: f32, color: raylib.Color, bold := false, shadow := false) {
-    w := measure_text(text, size, bold).x
+draw_text_centered :: proc(text: cstring, center_x, y, size: f32, color: raylib.Color,
+                           style: Font_Style = .REGULAR, shadow := false) {
+    w := measure_text(text, size, style).x
     pos := raylib.Vector2{center_x - w / 2, y}
     if shadow {
-        draw_text(text, pos + {0, size * 0.05}, size, raylib.Fade(themes.BLACK, 0.18), bold)
+        draw_text(text, pos + {0, size * 0.05}, size, raylib.Fade(themes.BLACK, 0.18), style)
     }
-    draw_text(text, pos, size, color, bold)
+    draw_text(text, pos, size, color, style)
 }
 
 // Draws text centered in a rectangle
-draw_text_in_rect :: proc(text: cstring, rect: raylib.Rectangle, size: f32, color: raylib.Color, bold := false) {
-    dims := measure_text(text, size, bold)
+draw_text_in_rect :: proc(text: cstring, rect: raylib.Rectangle, size: f32, color: raylib.Color,
+                          style: Font_Style = .REGULAR) {
+    dims := measure_text(text, size, style)
     pos := raylib.Vector2{rect.x + (rect.width - dims.x) / 2, rect.y + (rect.height - dims.y) / 2}
-    draw_text(text, pos, size, color, bold)
+    draw_text(text, pos, size, color, style)
 }
 
 draw_title :: proc(text: cstring, y: f32, color: raylib.Color, size: f32 = themes.TITLE_FONT_SIZE) {
-    draw_text_centered(text, themes.SCREEN_WIDTH / 2, y, size, color, bold = true, shadow = true)
+    draw_text_centered(text, themes.SCREEN_WIDTH / 2, y, size, color, style = .BOLD, shadow = true)
 }
 
-// A rounded button with hover, press and shadow states. Returns true when clicked.
+// A rounded button with hover, press and shadow states. Returns true when clicked
+// or when its hotkey is pressed.
 button :: proc(rect: raylib.Rectangle, text: cstring, color: raylib.Color,
-               text_color := themes.WHITE, font_size: f32 = themes.BUTTON_FONT_SIZE) -> bool {
+               text_color := themes.WHITE, font_size: f32 = themes.BUTTON_FONT_SIZE,
+               hotkey := raylib.KeyboardKey.KEY_NULL, selected := false) -> bool {
     hovered := raylib.CheckCollisionPointRec(raylib.GetMousePosition(), rect)
     pressed := hovered && raylib.IsMouseButtonDown(.LEFT)
     if hovered { set_hovered() }
@@ -76,9 +82,14 @@ button :: proc(rect: raylib.Rectangle, text: cstring, color: raylib.Color,
     raylib.DrawRectangleRounded(shadow, 0.4, 12, raylib.Fade(themes.BLACK, 0.18))
     body := raylib.Rectangle{rect.x, rect.y - lift, rect.width, rect.height}
     raylib.DrawRectangleRounded(body, 0.4, 12, fill)
-    draw_text_in_rect(text, body, font_size, text_color, bold = true)
+    if selected {
+        ring := raylib.Rectangle{body.x - 4, body.y - 4, body.width + 8, body.height + 8}
+        raylib.DrawRectangleRoundedLinesEx(ring, 0.4, 12, 3, color)
+    }
+    draw_text_in_rect(text, body, font_size, text_color, style = .BOLD)
 
     clicked := hovered && raylib.IsMouseButtonPressed(.LEFT)
+    if hotkey != .KEY_NULL && raylib.IsKeyPressed(hotkey) { clicked = true }
     if clicked { audio.play(.CLICK) }
     return clicked
 }