451 lines
16 KiB
Python
451 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""Menu systems for Storm Games.
|
|
|
|
Provides functionality for:
|
|
- Game menu navigation
|
|
- Instructions display
|
|
- Credits display
|
|
- Sound learning interface
|
|
- Game exit handling
|
|
"""
|
|
|
|
import pygame
|
|
import time
|
|
import webbrowser
|
|
import os
|
|
from sys import exit
|
|
from os.path import isfile
|
|
from os import listdir
|
|
from os.path import join
|
|
from inspect import isfunction
|
|
from .speech import messagebox, Speech
|
|
from .sound import adjust_master_volume, adjust_bgm_volume, adjust_sfx_volume, play_bgm
|
|
from .display import display_text
|
|
from .services import PathService
|
|
|
|
def game_menu(sounds, playCallback=None, *customOptions):
|
|
"""Display and handle the main game menu with standard and custom options.
|
|
|
|
Standard menu structure:
|
|
1. Play (always first)
|
|
2. High Scores (if scores exist)
|
|
3. Custom options (if provided)
|
|
4. Learn Sounds
|
|
5. Instructions (if available)
|
|
6. Credits (if available)
|
|
7. Donate
|
|
8. Exit
|
|
|
|
Handles navigation with:
|
|
- Up/Down arrows for selection
|
|
- Home/End for first/last option
|
|
- Enter to select
|
|
- Escape to exit
|
|
- Volume controls (with Alt modifier)
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
playCallback (function, optional): Callback function for the "play" option.
|
|
If None, "play" is returned as a string like other options.
|
|
*customOptions: Additional custom options to include after play but before standard ones
|
|
|
|
Returns:
|
|
str: Selected menu option or "exit" if user pressed escape
|
|
"""
|
|
# Get speech instance
|
|
speech = Speech.get_instance()
|
|
|
|
# Start with Play option
|
|
allOptions = ["play"]
|
|
|
|
# Add high scores option if scores exist
|
|
if has_high_scores():
|
|
allOptions.append("high_scores")
|
|
|
|
# Add custom options (other menu items, etc.)
|
|
allOptions.extend(customOptions)
|
|
|
|
# Add standard options in preferred order
|
|
allOptions.append("learn_sounds")
|
|
|
|
# Check for instructions file
|
|
if os.path.isfile('files/instructions.txt'):
|
|
allOptions.append("instructions")
|
|
|
|
# Check for credits file
|
|
if os.path.isfile('files/credits.txt'):
|
|
allOptions.append("credits")
|
|
|
|
# Final options
|
|
allOptions.extend(["donate", "exit_game"])
|
|
|
|
# Track if music was previously playing
|
|
musicWasPlaying = pygame.mixer.music.get_busy()
|
|
|
|
# Only start menu music if no music is currently playing
|
|
if not musicWasPlaying:
|
|
try:
|
|
from .sound import play_bgm
|
|
play_bgm("sounds/music_menu.ogg")
|
|
except:
|
|
pass
|
|
|
|
loop = True
|
|
pygame.mixer.stop()
|
|
currentIndex = 0
|
|
lastSpoken = -1 # Track last spoken index
|
|
|
|
while loop:
|
|
if currentIndex != lastSpoken:
|
|
speech.speak(allOptions[currentIndex])
|
|
lastSpoken = currentIndex
|
|
|
|
event = pygame.event.wait()
|
|
if event.type == pygame.KEYDOWN:
|
|
# Check for Alt modifier
|
|
mods = pygame.key.get_mods()
|
|
altPressed = mods & pygame.KMOD_ALT
|
|
|
|
# Volume controls (require Alt)
|
|
if altPressed:
|
|
if event.key == pygame.K_PAGEUP:
|
|
adjust_master_volume(0.1)
|
|
elif event.key == pygame.K_PAGEDOWN:
|
|
adjust_master_volume(-0.1)
|
|
elif event.key == pygame.K_HOME:
|
|
adjust_bgm_volume(0.1)
|
|
elif event.key == pygame.K_END:
|
|
adjust_bgm_volume(-0.1)
|
|
elif event.key == pygame.K_INSERT:
|
|
adjust_sfx_volume(0.1)
|
|
elif event.key == pygame.K_DELETE:
|
|
adjust_sfx_volume(-0.1)
|
|
# Regular menu navigation (no Alt required)
|
|
else:
|
|
if event.key == pygame.K_ESCAPE:
|
|
# Exit with fade if music is playing
|
|
exit_game(500 if pygame.mixer.music.get_busy() else 0)
|
|
elif event.key == pygame.K_HOME:
|
|
if currentIndex != 0:
|
|
currentIndex = 0
|
|
try:
|
|
sounds['menu-move'].play()
|
|
except:
|
|
pass
|
|
if allOptions[currentIndex] != "donate":
|
|
pygame.mixer.music.unpause()
|
|
elif event.key == pygame.K_END:
|
|
if currentIndex != len(allOptions) - 1:
|
|
currentIndex = len(allOptions) - 1
|
|
try:
|
|
sounds['menu-move'].play()
|
|
except:
|
|
pass
|
|
if allOptions[currentIndex] != "donate":
|
|
pygame.mixer.music.unpause()
|
|
elif event.key in [pygame.K_DOWN, pygame.K_s] and currentIndex < len(allOptions) - 1:
|
|
currentIndex += 1
|
|
try:
|
|
sounds['menu-move'].play()
|
|
except:
|
|
pass
|
|
if allOptions[currentIndex] != "donate":
|
|
pygame.mixer.music.unpause()
|
|
elif event.key in [pygame.K_UP, pygame.K_w] and currentIndex > 0:
|
|
currentIndex -= 1
|
|
try:
|
|
sounds['menu-move'].play()
|
|
except:
|
|
pass
|
|
if allOptions[currentIndex] != "donate":
|
|
pygame.mixer.music.unpause()
|
|
elif event.key == pygame.K_RETURN:
|
|
try:
|
|
lastSpoken = -1
|
|
try:
|
|
sounds['menu-select'].play()
|
|
time.sleep(sounds['menu-select'].get_length())
|
|
except:
|
|
pass
|
|
|
|
selectedOption = allOptions[currentIndex]
|
|
|
|
# Special case for exit_game with fade
|
|
if selectedOption == "exit_game":
|
|
exit_game(500 if pygame.mixer.music.get_busy() else 0)
|
|
# Special case for play option
|
|
elif selectedOption == "play":
|
|
if playCallback:
|
|
# If a play callback is provided, call it directly
|
|
try:
|
|
pygame.mixer.music.fadeout(500)
|
|
time.sleep(0.5)
|
|
except:
|
|
pass
|
|
playCallback()
|
|
else:
|
|
# Otherwise return "play" to the caller
|
|
return "play"
|
|
# Handle standard options directly
|
|
elif selectedOption in ["instructions", "credits", "learn_sounds", "high_scores", "donate"]:
|
|
# Pause music before calling the selected function
|
|
try:
|
|
pygame.mixer.music.pause()
|
|
except:
|
|
pass
|
|
|
|
# Handle standard options
|
|
if selectedOption == "instructions":
|
|
instructions()
|
|
elif selectedOption == "credits":
|
|
credits()
|
|
elif selectedOption == "learn_sounds":
|
|
learn_sounds(sounds)
|
|
elif selectedOption == "high_scores":
|
|
high_scores()
|
|
elif selectedOption == "donate":
|
|
donate()
|
|
|
|
# Unpause music after function returns
|
|
try:
|
|
# Check if music is actually paused before trying to unpause
|
|
if not pygame.mixer.music.get_busy():
|
|
pygame.mixer.music.unpause()
|
|
# If music is already playing, don't try to restart it
|
|
except:
|
|
# Only start fresh music if no music is playing at all
|
|
if not pygame.mixer.music.get_busy():
|
|
try:
|
|
from .sound import play_bgm
|
|
play_bgm("sounds/music_menu.ogg")
|
|
except:
|
|
pass
|
|
# Return custom options to the calling function
|
|
else:
|
|
lastSpoken = -1
|
|
try:
|
|
pygame.mixer.music.fadeout(500)
|
|
time.sleep(0.5)
|
|
except:
|
|
pass
|
|
return selectedOption
|
|
except Exception as e:
|
|
print(f"Error handling menu selection: {e}")
|
|
lastSpoken = -1
|
|
try:
|
|
pygame.mixer.music.fadeout(500)
|
|
time.sleep(0.5)
|
|
except:
|
|
pass
|
|
return allOptions[currentIndex]
|
|
|
|
event = pygame.event.clear()
|
|
time.sleep(0.001)
|
|
|
|
def learn_sounds(sounds):
|
|
"""Interactive menu for learning game sounds.
|
|
|
|
Allows users to:
|
|
- Navigate through available sounds
|
|
- Play selected sounds
|
|
- Return to menu with escape key
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of available sound objects
|
|
|
|
Returns:
|
|
str: "menu" if user exits with escape
|
|
"""
|
|
# Get speech instance
|
|
speech = Speech.get_instance()
|
|
|
|
currentIndex = 0
|
|
|
|
# Get list of available sounds, excluding special sounds
|
|
soundFiles = [f for f in listdir("sounds/")
|
|
if isfile(join("sounds/", f))
|
|
and (f.split('.')[1].lower() in ["ogg", "wav"])
|
|
and (f.split('.')[0].lower() not in ["game-intro", "music_menu"])
|
|
and (not f.lower().startswith("_"))]
|
|
|
|
# Track last spoken index to avoid repetition
|
|
lastSpoken = -1
|
|
|
|
# Flag to track when to exit the loop
|
|
returnToMenu = False
|
|
|
|
while not returnToMenu:
|
|
if currentIndex != lastSpoken:
|
|
speech.speak(soundFiles[currentIndex][:-4])
|
|
lastSpoken = currentIndex
|
|
|
|
event = pygame.event.wait()
|
|
if event.type == pygame.KEYDOWN:
|
|
if event.key == pygame.K_ESCAPE:
|
|
returnToMenu = True
|
|
|
|
if event.key in [pygame.K_DOWN, pygame.K_s] and currentIndex < len(soundFiles) - 1:
|
|
pygame.mixer.stop()
|
|
currentIndex += 1
|
|
|
|
if event.key in [pygame.K_UP, pygame.K_w] and currentIndex > 0:
|
|
pygame.mixer.stop()
|
|
currentIndex -= 1
|
|
|
|
if event.key == pygame.K_RETURN:
|
|
try:
|
|
soundName = soundFiles[currentIndex][:-4]
|
|
pygame.mixer.stop()
|
|
sounds[soundName].play()
|
|
except:
|
|
lastSpoken = -1
|
|
speech.speak("Could not play sound.")
|
|
|
|
event = pygame.event.clear()
|
|
time.sleep(0.001)
|
|
|
|
return "menu"
|
|
|
|
def has_high_scores():
|
|
"""Check if the current game has any high scores.
|
|
|
|
Returns:
|
|
bool: True if at least one high score exists, False otherwise
|
|
"""
|
|
try:
|
|
from .scoreboard import Scoreboard
|
|
board = Scoreboard()
|
|
scores = board.get_high_scores()
|
|
|
|
# Check if any score is greater than zero
|
|
return any(score['score'] > 0 for score in scores)
|
|
except Exception as e:
|
|
print(f"Error checking high scores: {e}")
|
|
return False
|
|
|
|
def high_scores():
|
|
"""Display high scores for the current game.
|
|
|
|
Reads the high scores from Scoreboard and displays them in order.
|
|
Shows the game name at the top followed by the available scores.
|
|
"""
|
|
try:
|
|
# Get PathService to access game name
|
|
pathService = PathService.get_instance()
|
|
gameName = pathService.gameName
|
|
|
|
# Create Scoreboard instance and get high scores
|
|
from .scoreboard import Scoreboard
|
|
board = Scoreboard()
|
|
scores = board.get_high_scores()
|
|
|
|
# Filter out scores with zero points
|
|
validScores = [score for score in scores if score['score'] > 0]
|
|
|
|
# Prepare the lines to display
|
|
lines = [f"High Scores for {gameName}:"]
|
|
|
|
# Add scores to the display list
|
|
if validScores:
|
|
for i, entry in enumerate(validScores, 1):
|
|
scoreStr = f"{i}. {entry['name']}: {entry['score']}"
|
|
lines.append(scoreStr)
|
|
else:
|
|
lines.append("No high scores yet.")
|
|
|
|
# Display the high scores
|
|
display_text(lines)
|
|
except Exception as e:
|
|
print(f"Error displaying high scores: {e}")
|
|
info = ["Could not display high scores."]
|
|
display_text(info)
|
|
|
|
def instructions():
|
|
"""Display game instructions from file.
|
|
|
|
Reads and displays instructions from 'files/instructions.txt'.
|
|
If file is missing, displays an error message.
|
|
"""
|
|
try:
|
|
with open('files/instructions.txt', 'r') as f:
|
|
info = f.readlines()
|
|
except:
|
|
info = ["Instructions file is missing."]
|
|
display_text(info)
|
|
|
|
def credits():
|
|
"""Display game credits from file.
|
|
|
|
Reads and displays credits from 'files/credits.txt'.
|
|
Adds game name header before displaying.
|
|
If file is missing, displays an error message.
|
|
"""
|
|
try:
|
|
with open('files/credits.txt', 'r') as f:
|
|
info = f.readlines()
|
|
|
|
pathService = PathService.get_instance()
|
|
info.insert(0, pathService.gameName + "\n")
|
|
except Exception as e:
|
|
print(f"Error in credits: {e}")
|
|
info = ["Credits file is missing."]
|
|
|
|
display_text(info)
|
|
|
|
def donate():
|
|
"""Open the donation webpage.
|
|
|
|
Opens the Ko-fi donation page.
|
|
"""
|
|
webbrowser.open('https://ko-fi.com/stormux')
|
|
messagebox("The donation page has been opened in your browser.")
|
|
|
|
def exit_game(fade=0):
|
|
"""Clean up and exit the game properly.
|
|
|
|
Args:
|
|
fade (int): Milliseconds to fade out music before exiting.
|
|
0 means stop immediately (default)
|
|
"""
|
|
# Force clear any pending events to prevent hanging
|
|
pygame.event.clear()
|
|
|
|
# Stop all mixer channels first
|
|
try:
|
|
pygame.mixer.stop()
|
|
except Exception as e:
|
|
print(f"Warning: Could not stop mixer channels: {e}")
|
|
|
|
# Get speech instance and handle all providers
|
|
try:
|
|
speech = Speech.get_instance()
|
|
# Try to close speech regardless of provider type
|
|
try:
|
|
speech.close()
|
|
except Exception as e:
|
|
print(f"Warning: Could not close speech: {e}")
|
|
except Exception as e:
|
|
print(f"Warning: Could not get speech instance: {e}")
|
|
|
|
# Handle music based on fade parameter
|
|
try:
|
|
if fade > 0 and pygame.mixer.music.get_busy():
|
|
pygame.mixer.music.fadeout(fade)
|
|
# Wait for fade to start but don't wait for full completion
|
|
pygame.time.wait(min(250, fade))
|
|
else:
|
|
pygame.mixer.music.stop()
|
|
except Exception as e:
|
|
print(f"Warning: Could not handle music during exit: {e}")
|
|
|
|
# Clean up pygame
|
|
try:
|
|
pygame.quit()
|
|
except Exception as e:
|
|
print(f"Warning: Error during pygame.quit(): {e}")
|
|
|
|
# Use os._exit for immediate termination
|
|
import os
|
|
os._exit(0)
|