def __init__(self, render_surface, surface_size):
Screen.__init__(self, render_surface, surface_size)
self.widgets = {
"heading_kanjioptionsscreen":
Heading(self.render_surface, (0, 0, 1920, 100),
"Kanji Options").set_themed(),
"button_back":
Button(self.render_surface, (10, 10, 230, 80),
"Back").set_themed(),
}
self.checkboxes = {
"kanji_show_kun":
Checkbox(self.render_surface, (600, 400, 720, 100),
"Show 'kun' reading").set_themed(),
"kanji_show_on":
Checkbox(self.render_surface, (600, 550, 720, 100),
"Show 'on' reading").set_themed(),
"kanji_show_dutch":
Checkbox(self.render_surface, (600, 700, 720, 100),
"Show Dutch").set_themed(),
}
# set the 'selected' property of the checkboxes
for checkbox_id, checkbox in self.checkboxes.items():
checkbox.selected = Settings.get(checkbox_id)
def prepare(self):
self.randomize_kana = Settings.get("randomize_kana")
# load the selected kana from the hiragana/katakana tables
self.selected_kana = []
kana_names = ["hiragana", "katakana"]
for kana_name in kana_names:
kana = Kana(kana_name)
if not Settings.get(f"learn_{kana_name}"):
continue
for kana_name in Settings.get(f"{kana_name}_kana"):
self.selected_kana.append({"kana": kana, "name": kana_name})
if Settings.get("learn_kanji"):
kanji = Kanji("kanji.json")
for kanji_entry in kanji.kanji_dict:
self.selected_kana.append({**kanji_entry, "name": "kanji"})
# parameters for the scoring system
self.total_kana = len(self.selected_kana)
self.wrong_kana = 0
# update the progress system numbers
self._update_progress_system()
# handle case where no kana is selected
if not self.selected_kana:
self._update_scoring_system()
self.state = "done"
self._clear_drawing_surface()
return
# start with some initial index
if self.randomize_kana:
# if randomize, simply get a random index from the kana left
self.index = random.randint(0, len(self.selected_kana) - 1)
else:
# if not randomized, start at the first kana, index 0
self.index = 0
# get a reference to the current kana
self.kana = self.selected_kana[self.index]
# get kanji settings
self.kanji_show = {}
for item in ["kun", "on", "dutch"]:
self.kanji_show[item] = Settings.get(f"kanji_show_{item}")
self.state = "draw"
self._clear_drawing_surface()
def __init__(self):
# set the display name
pygame.display.set_caption("Kanaraimasu - Learn to draw kana")
# initialize the game parameters
self.fps = Settings.get("fps")
# initialize the screen and render surfaces
width = Settings.get("width")
height = Settings.get("height")
fullscreen = pygame.FULLSCREEN if Settings.get("fullscreen") else 0
self.screen_size = (width, height)
self.pg_screen = pygame.display.set_mode(self.screen_size,
RESIZABLE | fullscreen)
self.render_size = (1920, 1080)
self.render_surface = pygame.Surface(self.render_size)
self.show_splash_screen()
# initialize the screens
self.screens = {
"gamescreen":
GameScreen(self.render_surface, self.render_size),
"optionsforhiragana":
KanaSelectScreen(self.render_surface, self.render_size,
"hiragana"),
"optionsforkatakana":
KanaSelectScreen(self.render_surface, self.render_size,
"katakana"),
"optionsforkanji":
KanjiOptionsScreen(self.render_surface, self.render_size),
"menuscreen":
MenuScreen(self.render_surface, self.render_size),
"settingsscreen":
SettingsScreen(self.render_surface, self.render_size),
}
self.set_screen_id("menuscreen")
# sets the screen size in all screens
self.set_screen_size(self.screen_size)
self.game_time = time.time()
# run the game loop forever
while True:
self.game_loop()
def update_theme_index(self, change):
themes = Settings.get("themes")
last_theme_index = len(themes) - 1
# update and bounds check the theme index
index = self.theme_index + change
index = last_theme_index if index < 0 else index
index = 0 if index > last_theme_index else index
# update the class' theme index and the text
self.theme_index = index
apply_theme_text = f"Apply theme: {list(themes.keys())[index]}"
self.theme_apply.set_text(apply_theme_text)
def __init__(self, render_surface, surface_size, kana_name):
Screen.__init__(self, render_surface, surface_size)
self.kana_name = kana_name
self.kana = Kana(self.kana_name)
self.widgets = {
"heading_kanaselectscreen":
Heading(
self.render_surface,
(0, 0, 1920, 100),
f"Select Kana: {self.kana_name}",
).set_themed(),
"button_back":
Button(self.render_surface, (10, 10, 230, 80),
"Back").set_themed(),
}
self.checkboxes = {}
self.row_checkboxes = {}
self.col_checkboxes = {}
width_factor = 1520 / 6000
height_factor = 950 / 3750
width = 500 * width_factor
height = 625 * height_factor
kana_list = Settings.get(f"{self.kana_name}_kana")
gen_checkbox = lambda kana, data: Checkbox(
self.render_surface,
(
data["x"] * width_factor + 200,
data["y"] * height_factor + 115,
width,
height,
),
box_only=True,
themed=True,
).set_selected(kana not in kana_list)
for kana, data in self.kana.table.items():
self.checkboxes[kana] = gen_checkbox(kana, data)
for row_name, data in self.kana.row_table.items():
self.row_checkboxes[row_name] = gen_checkbox(row_name, data)
for col_name, data in self.kana.col_table.items():
self.col_checkboxes[col_name] = gen_checkbox(col_name, data)
# update the rows and columns which could be wrong by default
self._update_kana()
def mouse_event(self, event):
Screen.mouse_event(self, event)
if event.type == pygame.MOUSEBUTTONUP:
if self.widgets["button_menu"].rect_hit(event.pos):
return {"screen_id": "menuscreen"}
for kana_widget_id, kana_widget in self.kana_widgets.items():
checkbox = kana_widget["checkbox"]
# check whether the kana checkboxes are hit
checkbox.on_mouse_release(event.pos)
if checkbox.rect_hit(event.pos):
# checkbox is hit, save the new setting
Settings.set(kana_widget["setting"], checkbox.selected)
# check whether the buttons are hit
if kana_widget["button"].rect_hit(event.pos):
return {"screen_id": f"optionsfor{kana_widget_id}"}
for checkbox_widget_id, checkbox_widget in self.checkboxes.items():
checkbox = checkbox_widget["checkbox"]
checkbox.on_mouse_release(event.pos)
if checkbox.rect_hit(event.pos):
# checkbox is hit, save the new setting
Settings.set(checkbox_widget["setting"], checkbox.selected)
# theme switcher related buttons
if self.theme_left.rect_hit(event.pos):
self.update_theme_index(-1)
if self.theme_right.rect_hit(event.pos):
self.update_theme_index(1)
if self.theme_apply.rect_hit(event.pos):
# get the theme from the index and save the new theme
theme = list(Settings.get("themes").keys())[self.theme_index]
Settings.set("theme", theme)
# update the text on the current theme widget
self.widgets["theme_text"].set_text(
f"Current theme: '{theme}'"
)
# reapply the (new) theme to the GUI
Collections.reapply_theme()
def __init__(self, render_surface, surface_size):
Screen.__init__(self, render_surface, surface_size)
# the surface where the user draws on
self.drawing_surface = pygame.Surface(self.surface_size)
self.stroke_width = Settings.get("stroke_width")
self.bounding_box_color = Theme.get_color("foreground")
self.cross_color = Theme.get_color("secondary")
self.draw_color = Theme.get_color("draw")
# ingame parameters
self.pos = (0, 0)
# widgets that are always present
self.widgets = {
"heading":
Heading(self.render_surface, (0, 0, 1920, 100)).set_themed(),
"button_menu":
Button(self.render_surface, (10, 10, 230, 80),
"Menu").set_themed(),
"progress_text":
Text(self.render_surface, (10, 125, 1900, 100),
"Completed: X / Y").set_align(
Text.ALIGN_RIGHT_CENTER).set_themed(),
}
# widgets that are kanji related
self.kanji_widgets = [
# these are used to show up to 3 lines of kanji information
Text(
self.render_surface,
(1160, i, 660, 100),
).set_font_size(65).set_align(Text.ALIGN_LEFT_TOP).set_themed()
for i in [225, 285, 345]
]
self.kanji_widgets.append(
# this is the kanji character itself
Text(self.render_surface,
(1160, 400, 660, 660)).set_font_size(500).set_font_name(
"assets/font/KanjiStrokeOrders_v2.016.ttf").set_themed())
# widgets in draw state
self.clear_button = (Button(self.render_surface, (860, 290, 200, 150),
"Clear").set_font_size(90).set_themed())
self.done_button = Button(self.render_surface, (860, 490, 200, 200),
"Done").set_themed()
# widgets in the verify state
self.wrong_button = (Button(
self.render_surface, (860, 290, 200, 150),
"Wrong").set_font_size(80).set_themed().set_rect_color(
Theme.get_color("bad")))
self.good_button = (Button(self.render_surface, (860, 490, 200, 200),
"Good").set_themed().set_rect_color(
Theme.get_color("good")))
# widgets in the done state
self.score_widget = Text(
self.render_surface,
(0, 550, 1920, 200),
"Learned x kana while making y mistakes",
).set_themed()
done_widgets = [
Text(self.render_surface, (0, 400, 1920, 200),
"Done!").set_font_size(200).set_themed(),
self.score_widget,
Text(
self.render_surface,
(0, 650, 1920, 200),
"Go back to the menu to try again,",
).set_themed(),
Text(
self.render_surface,
(0, 750, 1920, 200),
"or change the kana you want to learn",
).set_themed(),
]
self.state_widgets = {
"draw": [self.clear_button, self.done_button],
"verify": [self.wrong_button, self.good_button],
"done": done_widgets,
}
def __init__(self, render_surface, surface_size):
Screen.__init__(self, render_surface, surface_size)
self.checkboxes = {
"randomize_kana": {
"checkbox": Checkbox(
self.render_surface,
(600, 450, 720, 100),
"Randomize Kana",
).set_themed(),
"setting": "randomize_kana",
},
}
self.kana_widgets = {
"hiragana": {
"checkbox": Checkbox(
self.render_surface,
(200, 600, 700, 100),
"Learn Hiragana",
).set_themed(),
"button": Button(
self.render_surface,
(1000, 600, 700, 100),
"Select which kana",
).set_themed(),
"setting": "learn_hiragana",
},
"katakana": {
"checkbox": Checkbox(
self.render_surface,
(200, 750, 700, 100),
"Learn Katakana",
).set_themed(),
"button": Button(
self.render_surface,
(1000, 750, 700, 100),
"Select which kana",
).set_themed(),
"setting": "learn_katakana",
},
"kanji": {
"checkbox": Checkbox(
self.render_surface,
(200, 900, 700, 100),
"Learn Kanji",
).set_themed(),
"button": Button(
self.render_surface,
(1000, 900, 700, 100),
"Kanji options",
).set_themed(),
"setting": "learn_kanji",
},
}
# set the 'selected' property of the checkboxes and kana_widgets
for checkbox_widget_id, checkbox_widget in self.checkboxes.items():
checkbox = checkbox_widget["checkbox"]
checkbox.selected = Settings.get(checkbox_widget["setting"])
for kana_widget_id, kana_widget in self.kana_widgets.items():
checkbox = kana_widget["checkbox"]
checkbox.selected = Settings.get(kana_widget["setting"])
theme = Settings.get("theme")
themes = Settings.get("themes")
self.widgets = {
"heading_settings": Heading(
self.render_surface, (0, 0, 1920, 100), "Settings"
).set_themed(),
"button_menu": Button(
self.render_surface, (10, 10, 230, 80), "Menu"
).set_themed(),
"theme_text": Text(
self.render_surface,
(500, 150, 920, 100),
f"Current theme: '{theme}'",
).set_themed(),
}
# get the theme index of the current theme
if theme in themes:
self.theme_index = list(themes.keys()).index(theme)
else:
# somehow the theme in the settings file isn't available, reset
print(f"theme {theme} is invalid! resetting to default")
self.theme_index = 0
Settings.set("theme", next(iter(themes)))
Collections.reapply_theme()
# theme related widgets
theme_name = list(themes.keys())[self.theme_index]
apply_theme_text = f"Apply theme: {theme_name}"
self.theme_left = Button(
self.render_surface, (300, 275, 100, 100), "<"
).set_themed()
self.theme_apply = Button(
self.render_surface, (500, 275, 920, 100), apply_theme_text
).set_themed()
self.theme_right = Button(
self.render_surface, (1520, 275, 100, 100), ">"
).set_themed()