SansanandClaude Opus 5.5
8214fda8f6
- 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>
273 lines
9.5 KiB
Odin
273 lines
9.5 KiB
Odin
package tests
|
|
|
|
import "core:testing"
|
|
import assets "../src/assets"
|
|
import decks "../src/decks"
|
|
import card "../src/card"
|
|
import memory "../src/memory"
|
|
import themes "../src/themes"
|
|
|
|
// Runs the game logic forward in small steps, like frames
|
|
@(private)
|
|
advance :: proc(seconds: f32) {
|
|
dt: f32 = 1.0 / 60
|
|
for t: f32 = 0; t < seconds; t += dt {
|
|
memory.update(dt)
|
|
}
|
|
}
|
|
|
|
// Finds the card index holding the other half of card i's pair
|
|
@(private)
|
|
partner_of :: proc(i: int) -> int {
|
|
for c, j in memory.active_cards() {
|
|
if j != i && c.pair_id == memory.cards[i].pair_id { return j }
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// Finds a card index that does not pair with card i
|
|
@(private)
|
|
non_partner_of :: proc(i: int) -> int {
|
|
for c, j in memory.active_cards() {
|
|
if j != i && c.pair_id != memory.cards[i].pair_id { return j }
|
|
}
|
|
return -1
|
|
}
|
|
|
|
@(test)
|
|
deck_sizes :: proc(t: ^testing.T) {
|
|
testing.expect_value(t, len(decks.entries(.HIRAGANA)), 46)
|
|
testing.expect_value(t, len(decks.entries(.KATAKANA)), 46)
|
|
testing.expect_value(t, len(decks.entries(.HANGUL)), 24)
|
|
testing.expect_value(t, len(decks.entries(.THAI_CONSONANTS)), 42)
|
|
}
|
|
|
|
@(test)
|
|
decks_have_unique_symbols_and_readings :: proc(t: ^testing.T) {
|
|
for deck in decks.Deck_Id {
|
|
entries := decks.entries(deck)
|
|
for a, i in entries {
|
|
for b, j in entries {
|
|
if i == j { continue }
|
|
testing.expectf(t, a.symbol != b.symbol, "%v: duplicate symbol %s", deck, a.symbol)
|
|
// Readings may repeat (e.g. Thai "kh") only when the hint tells them apart
|
|
same_reading := a.reading == b.reading && a.hint == b.hint
|
|
testing.expectf(t, !same_reading, "%v: %s and %s read the same", deck, a.symbol, b.symbol)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@(private)
|
|
covers :: proc(codepoints: []rune, text: cstring) -> (missing: rune, ok: bool) {
|
|
outer: for r in string(text) {
|
|
for c in codepoints {
|
|
if c == r { continue outer }
|
|
}
|
|
return r, false
|
|
}
|
|
return 0, true
|
|
}
|
|
|
|
// raylib renders "?" for any glyph that wasn't baked into the font
|
|
@(test)
|
|
fonts_cover_every_deck_character :: proc(t: ^testing.T) {
|
|
for deck in decks.Deck_Id {
|
|
symbol_points := assets.codepoints_for(decks.language_of(deck).symbol_style)
|
|
defer delete(symbol_points)
|
|
ui_points := assets.codepoints_for(.BOLD)
|
|
defer delete(ui_points)
|
|
for entry in decks.entries(deck) {
|
|
if r, ok := covers(symbol_points[:], entry.symbol); !ok {
|
|
testing.expectf(t, false, "%v: %s needs %r in the symbol font", deck, entry.symbol, r)
|
|
}
|
|
if r, ok := covers(ui_points[:], entry.reading); !ok {
|
|
testing.expectf(t, false, "%v: %s needs %r in the UI font", deck, entry.reading, r)
|
|
}
|
|
if entry.hint == nil { continue }
|
|
if r, ok := covers(ui_points[:], entry.hint); !ok {
|
|
testing.expectf(t, false, "%v: %s needs %r in the UI font", deck, entry.hint, r)
|
|
}
|
|
}
|
|
info := decks.DECKS[deck]
|
|
if r, ok := covers(symbol_points[:], info.native); !ok {
|
|
testing.expectf(t, false, "%v: deck name %s needs %r", deck, info.native, r)
|
|
}
|
|
}
|
|
for language in decks.Language {
|
|
info := decks.LANGUAGES[language]
|
|
points := assets.codepoints_for(info.congrats_style)
|
|
defer delete(points)
|
|
if r, ok := covers(points[:], info.congrats); !ok {
|
|
testing.expectf(t, false, "%v: %s needs %r", language, info.congrats, r)
|
|
}
|
|
native_points := assets.codepoints_for(info.symbol_style)
|
|
defer delete(native_points)
|
|
if r, ok := covers(native_points[:], info.native); !ok {
|
|
testing.expectf(t, false, "%v: %s needs %r", language, info.native, r)
|
|
}
|
|
}
|
|
}
|
|
|
|
@(test)
|
|
deal_creates_symbol_reading_pairs :: proc(t: ^testing.T) {
|
|
for deck in decks.Deck_Id {
|
|
for difficulty in memory.Difficulty {
|
|
memory.deal(deck, difficulty)
|
|
layout := memory.LAYOUTS[difficulty]
|
|
testing.expect_value(t, memory.card_count, layout.rows * layout.cols)
|
|
testing.expect_value(t, memory.pair_count, memory.card_count / 2)
|
|
testing.expect_value(t, memory.state, memory.State.WAITING)
|
|
testing.expect_value(t, memory.moves, 0)
|
|
testing.expect_value(t, memory.matches, 0)
|
|
|
|
for pair in 0 ..< memory.pair_count {
|
|
symbol_count, reading_count := 0, 0
|
|
symbol, reading, hint: cstring
|
|
for c in memory.active_cards() {
|
|
if c.pair_id != pair { continue }
|
|
testing.expect(t, !c.face_up && !c.matched)
|
|
if c.is_symbol {
|
|
symbol_count += 1
|
|
symbol = c.text
|
|
} else {
|
|
reading_count += 1
|
|
reading = c.text
|
|
hint = c.hint
|
|
}
|
|
}
|
|
testing.expect_value(t, symbol_count, 1)
|
|
testing.expect_value(t, reading_count, 1)
|
|
|
|
// The two halves must belong to the same deck entry
|
|
found := false
|
|
for entry in decks.entries(deck) {
|
|
if entry.symbol == symbol && entry.reading == reading && entry.hint == hint { found = true }
|
|
}
|
|
testing.expectf(t, found, "%v pair %d is %s/%s, which is not in the deck", deck, pair, symbol, reading)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@(test)
|
|
deal_lays_out_cards_on_screen_without_overlap :: proc(t: ^testing.T) {
|
|
for difficulty in memory.Difficulty {
|
|
memory.deal(.HIRAGANA, difficulty)
|
|
for a, i in memory.active_cards() {
|
|
testing.expect(t, a.rect.x >= 0 && a.rect.x + a.rect.width <= themes.SCREEN_WIDTH)
|
|
testing.expect(t, a.rect.y >= themes.GRID_TOP && a.rect.y + a.rect.height <= themes.SCREEN_HEIGHT)
|
|
for b, j in memory.active_cards() {
|
|
if i == j { continue }
|
|
overlap := a.rect.x < b.rect.x + b.rect.width && b.rect.x < a.rect.x + a.rect.width &&
|
|
a.rect.y < b.rect.y + b.rect.height && b.rect.y < a.rect.y + a.rect.height
|
|
testing.expectf(t, !overlap, "cards %d and %d overlap", i, j)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@(test)
|
|
matching_pair_stays_up :: proc(t: ^testing.T) {
|
|
memory.deal(.HIRAGANA, .NORMAL)
|
|
a := 0
|
|
b := partner_of(a)
|
|
|
|
testing.expect(t, memory.select_card(a))
|
|
testing.expect_value(t, memory.state, memory.State.FIRST)
|
|
testing.expect(t, memory.select_card(b))
|
|
testing.expect_value(t, memory.state, memory.State.RESOLVING)
|
|
testing.expect_value(t, memory.moves, 1)
|
|
|
|
advance(2)
|
|
testing.expect_value(t, memory.state, memory.State.WAITING)
|
|
testing.expect_value(t, memory.matches, 1)
|
|
testing.expect(t, memory.cards[a].matched && memory.cards[b].matched)
|
|
testing.expect(t, memory.cards[a].face_up && memory.cards[b].face_up)
|
|
}
|
|
|
|
@(test)
|
|
mismatched_pair_flips_back :: proc(t: ^testing.T) {
|
|
memory.deal(.HIRAGANA, .NORMAL)
|
|
a := 0
|
|
b := non_partner_of(a)
|
|
|
|
memory.select_card(a)
|
|
memory.select_card(b)
|
|
advance(3)
|
|
testing.expect_value(t, memory.state, memory.State.WAITING)
|
|
testing.expect_value(t, memory.matches, 0)
|
|
testing.expect_value(t, memory.moves, 1)
|
|
testing.expect(t, !memory.cards[a].face_up && !memory.cards[b].face_up)
|
|
testing.expect_value(t, memory.cards[a].flip_t, 0)
|
|
}
|
|
|
|
@(test)
|
|
invalid_picks_are_rejected :: proc(t: ^testing.T) {
|
|
memory.deal(.HIRAGANA, .NORMAL)
|
|
a := 0
|
|
testing.expect(t, memory.select_card(a))
|
|
testing.expect(t, !memory.select_card(a)) // same card twice
|
|
|
|
b := non_partner_of(a)
|
|
memory.select_card(b)
|
|
c := non_partner_of(b)
|
|
for c == a { c += 1 }
|
|
testing.expect(t, !memory.select_card(c)) // a third card while resolving
|
|
testing.expect_value(t, memory.moves, 1)
|
|
|
|
memory.deal(.HIRAGANA, .NORMAL)
|
|
p := partner_of(0)
|
|
memory.select_card(0)
|
|
memory.select_card(p)
|
|
advance(2)
|
|
testing.expect(t, !memory.select_card(0)) // already matched
|
|
}
|
|
|
|
@(test)
|
|
finding_all_pairs_wins :: proc(t: ^testing.T) {
|
|
memory.deal(.HIRAGANA, .NORMAL)
|
|
for i in 0 ..< memory.card_count {
|
|
if memory.cards[i].matched { continue }
|
|
memory.select_card(i)
|
|
memory.select_card(partner_of(i))
|
|
advance(2)
|
|
}
|
|
testing.expect_value(t, memory.state, memory.State.OVER)
|
|
testing.expect_value(t, memory.matches, memory.pair_count)
|
|
testing.expect_value(t, memory.moves, memory.pair_count)
|
|
for &c in memory.active_cards() { testing.expect(t, c.matched) }
|
|
|
|
// The clock stops once the game is over
|
|
elapsed := memory.elapsed
|
|
advance(1)
|
|
testing.expect_value(t, memory.elapsed, elapsed)
|
|
}
|
|
|
|
@(test)
|
|
card_flip_animation_reaches_target :: proc(t: ^testing.T) {
|
|
c := card.Card{}
|
|
testing.expect(t, !card.is_animating(&c))
|
|
|
|
c.face_up = true
|
|
testing.expect(t, card.is_animating(&c))
|
|
card.update(&c, 0.1)
|
|
testing.expect(t, c.flip_t > 0 && c.flip_t < 1)
|
|
for _ in 0 ..< 60 { card.update(&c, 1.0 / 60) }
|
|
testing.expect_value(t, c.flip_t, 1)
|
|
testing.expect(t, !card.is_animating(&c))
|
|
|
|
c.face_up = false
|
|
for _ in 0 ..< 60 { card.update(&c, 1.0 / 60) }
|
|
testing.expect_value(t, c.flip_t, 0)
|
|
}
|
|
|
|
@(test)
|
|
card_pulse_counts_down :: proc(t: ^testing.T) {
|
|
c := card.Card{}
|
|
card.start_pulse(&c)
|
|
testing.expect_value(t, c.pulse_t, card.PULSE_DURATION)
|
|
card.update(&c, 1)
|
|
testing.expect_value(t, c.pulse_t, 0)
|
|
}
|