playMusic(menu_background_path)
# Found on pygame docs
# https://www.pygame.org/docs/ref/cursors.html
# Believe it makes the cursor look nicer in the game
pygame.mouse.set_cursor(*pygame.cursors.tri_left)
### Main Game Loop
while start_menu.playing:
# Limit frame rate
clock.tick(max_fps)
# Get/action events
for event in pygame.event.get():
# Send each event to the start menu
button_out = start_menu.do(event)
if button_out == 'settings':
SettingsMenu(menu_screen, max_fps)
# Refresh screen
menu_screen.fill(colour['black'])
### Code to re-display items on screen will go here
start_menu.display()
# Display everything on screen
pygame.display.flip()
quitGame()
def gameOver(screen, score, delay):
def saveScore():
'''
Function which takes user name and current score and stores it
in a text file.
'''
saves = open(HIGH_SCORE_LOCATION, 'a')
saved_score = f'{player_name.text}/{score.text}\n'
saves.write(saved_score)
saves.close()
# load clock
clock = pygame.time.Clock()
# Generate useful positions
width = screen.get_width()
height = screen.get_height()
mid = width // 2
left = width // 5
right = 4 * left
height_unit = height // 20
# Load previous scores and calculate highscore
scores = loadScoreList()
if (len(scores) > 0) and (scores[-1][-1] >= score):
highscore_string = f'{scores[-1][0]} : {scores[-1][-1]}'
else:
highscore_string = f'You! : {score}'
# Text input is active
active = True
started = False
# Creating text for the main header.
menu_title = Text(screen, (mid, 2 * height_unit), 70, 'Game Over',
'Purple')
# Creating a header for the score.
score_header = Text(screen, (mid, 4 * height_unit), 30, f'HIGHSCORE')
# Creating text object for the highest score of the game
high_score = Text(screen, (mid, 5 * height_unit), 25, highscore_string)
# Creating text object for the current score of the game
your_score = Text(screen, (mid, 7 * height_unit), 30, f'YOUR SCORE')
# Creating object for the current score.
score = Text(screen, (mid, 8 * height_unit), 25, f'{score}')
player_name_center = (mid, 9 * height_unit)
player_name = Text(screen, player_name_center, 30, '[Enter Name Here]',
'yellow')
save_score = Button(screen, 'Save Score', (mid, 11 * height_unit),
(lambda: 'save'), 25, (200, 64))
# Creating a button for scoreboard.
score_board = Button(screen, 'Scoreboard', (left, 18.5 * height_unit // 1),
(lambda: 'scoreboard'), 25, (200, 64))
# Creating a button for main menu.
back_to_menu = Button(screen, 'Main menu', (mid, 18.5 * height_unit // 1),
(lambda: 'main_menu'), 25, (200, 64))
# Creating a button to exit the game
exit_game = Button(screen, 'Quit', (right, 18.5 * height_unit // 1),
quitGame, 25, (200, 64))
menu = Menu(screen, menu_title, BACKGROUND_LOCATION, back_to_menu,
score_board, exit_game, save_score)
saved_menu = Menu(screen, menu_title, BACKGROUND_LOCATION, back_to_menu,
score_board, exit_game)
# Game over screen loop which checks for inputs of buttons and user text input.
run = True
while run:
clock.tick(delay)
# Get/action events
for event in pygame.event.get():
# Send each event to the start menu
if event.type == pygame.QUIT:
# Detecting user pressing quit button, if X pressed,
# break loop and quit screen.
quitGame()
# Check if the text box is pressed on.
# If so user can input text in to the box and
# save it to the variable user_name.
if event.type == pygame.KEYDOWN:
if active:
if event.key == pygame.K_BACKSPACE:
player_name.text = player_name.text[0:-1]
player_name.position = player_name.position
elif pygame.key.name(event.key) in ALPHABET:
if not started:
player_name.text = ''
started = True
player_name.text += event.unicode
player_name.position = player_name_center[0], \
player_name_center[1]
player_name.makeRect()
# Do mouse up/down events
elif (event.type == pygame.MOUSEBUTTONDOWN) or \
(event.type == pygame.MOUSEBUTTONUP):
button_press = menu.do(event)
if button_press == 'main_menu':
run = False
elif button_press == 'scoreboard':
scoreBoard(screen, delay)
elif button_press == 'save':
saveScore()
active = False
menu = saved_menu
player_name.colour = 'white'
# Blit the background image to the screen.
screen.fill('black')
# Make a rect for the text box
#pygame.draw.rect(screen, color, input_rect)
# Render the text inputted by the user.
#text_surface = base_font.render(user_name, True, (255, 255, 255))
# Blit the text to screen
#screen.blit(text_surface, (input_rect.x + 5, input_rect.y + 5))
# Place the text on the rectangle
#input_rect.w = max(100, text_surface.get_width() + 10)
# Display menu here - this will display all buttons included in
# the menu
# menu.display()
# Text (apart from menu title text) needs to be displayed
# separately
menu.display()
player_name.display()
score_header.display()
score.display()
high_score.display()
your_score.display()
pygame.display.flip()
def scoreBoard(screen, delay):
'''
Function which creates a screen where a score bored is displayed by
using the values from highscores.txt.
'''
# establishing a clock for the screen
clock = pygame.time.Clock()
# Creating width and height variables.
width = screen.get_width()
height = screen.get_height()
# loading a list from game over screen with the newest scores.
score_list = loadScoreList()
if len(score_list) < 10:
n_scores = len(score_list)
else:
n_scores = 10
# Creating text objects for n highest scores.
Header = Text(screen, (width // 2, height // 8), 50,
f'TOP {n_scores} SCORES', 'purple')
score_objects = []
for k in range(n_scores):
index = - 1 * (k + 1)
score_objects.append(
Text(screen, (width // 2, 120 + (k * 40)), 35,
f'{score_list[index][0]} = {score_list[index][1]}')
)
# Creating a button for going back to the game over screen.
back = Button(screen, 'Back', (400, 585), (lambda: 'go_back'), 25,
(126, 64))
menu = Menu(screen, Header, False, back)
# Creating a loop for the scoreboard screen.
run = True
while run:
clock.tick(delay)
for event in pygame.event.get():
# Send each event to the start menu
if event.type == pygame.QUIT:
# Detecting user pressing quit button, if X pressed,
# break loop and quit screen.
quitGame()
# Checking if the Back button is being pressed.
elif (event.type == pygame.MOUSEBUTTONDOWN) or \
(event.type == pygame.MOUSEBUTTONUP):
button_press = menu.do(event)
if button_press == 'go_back':
run = False
# Bliting background image.
screen.blit(background, (0, 0))
# Bliting text objects and button to screen.
for score_object in score_objects:
score_object.display()
menu.display()
pygame.display.flip()
class SettingsMenu:
def __init__(self, screen, max_fps):
self.run = True
# Key game variables
self.screen = screen
self.max_fps = max_fps
# Size variables based on screen size
self.height = screen.get_height()
self.width = screen.get_width()
self.height_unit = self.height // 9
self.left = self.width // 4
self.right = 3 * self.left
self.mid = self.width // 2
self.default_button = (128, 64)
# Make texts and menu
self.refreshTexts()
self.makeMenu()
# Run settings menu
self.runSettings()
def loadSettings(self):
'''
Loads settings json as python dictionary and assigns to
self.settings_data
'''
with open(SETTINGS_LOCATION) as settings_data:
self.settings_data = json.load(settings_data)
def refreshTexts(self):
'''
Re-loads settings JSON and refreshes the text elements.
The texts dictionary contains all text elements to display,
while the used_keys dictionary contains the data for all keys
that have been assigned by the user.
'''
self.loadSettings()
texts = {}
self.used_keys = [
self.settings_data["left"], self.settings_data["right"],
self.settings_data["up"], self.settings_data["attack"],
self.settings_data["next_level"]
]
screen = self.screen
left_str = f'Move Left : {self.settings_data["left"]}'
left_text = Text(screen, (self.left, 2 * self.height_unit), 35,
left_str)
texts['left'] = left_text
right_str = f'Move Right : {self.settings_data["right"]}'
right_text = Text(screen, (self.left, 3 * self.height_unit), 35,
right_str)
texts['right'] = right_text
jump_str = f'Jump : {self.settings_data["up"]}'
jump_text = Text(screen, (self.left, 4 * self.height_unit), 35,
jump_str)
texts['up'] = jump_text
attack_str = f'Attack : {self.settings_data["attack"]}'
attack_text = Text(screen, (self.left, 5 * self.height_unit), 35,
attack_str)
texts['attack'] = attack_text
level_str = f'Next Level : {self.settings_data["next_level"]}'
level_text = Text(screen, (self.left, 6 * self.height_unit), 35,
level_str)
texts['next_level'] = level_text
self.texts = texts
self.changing = (False, None)
def resetButton(self):
with open(DEFAULT_LOCATION) as default_settings:
default_settings = json.load(default_settings)
with open(SETTINGS_LOCATION, 'w') as settings_json:
json.dump(default_settings, settings_json)
self.refreshTexts()
self.makeMusicButton()
self.compileMenu()
def backButton(self):
self.run = False
def changeMusic(self):
music_index = self.settings_data['music']
music_index += 1
n_tracks = len(MUSIC_LOCATIONS['tracks'])
if music_index >= n_tracks:
music_index = 0
self.settings_data['music'] = music_index
self.saveSettings()
self.makeMusicButton()
self.compileMenu()
def saveSettings(self):
with open(SETTINGS_LOCATION, 'w') as settings_json:
json.dump(self.settings_data, settings_json)
def makeNormalButtons(self):
screen = self.screen
# Back Button - breaks loop and returns to main menu
back_pos = self.default_button[
0] + 10, self.height - self.default_button[1] - 10
self.back_button = Button(screen, 'Back', back_pos, self.backButton,
20)
# Reset Button
reset_pos = self.width - back_pos[0], back_pos[1]
self.reset_button = Button(screen, 'Reset', reset_pos,
self.resetButton, 20)
# Left
self.left_button = Button(screen, 'Change',
(self.right, 2 * self.height_unit),
(lambda: 'left'), 20)
# Right
self.right_button = Button(screen, 'Change',
(self.right, 3 * self.height_unit),
(lambda: 'right'), 20)
# Jump
self.jump_button = Button(screen, 'Change',
(self.right, 4 * self.height_unit),
(lambda: 'up'), 20)
# Attack
self.attack_button = Button(screen, 'Change',
(self.right, 5 * self.height_unit),
(lambda: 'attack'), 20)
# Next Level
self.level_button = Button(screen, 'Change',
(self.right, 6 * self.height_unit),
(lambda: 'next_level'), 20)
def makeMusicButton(self):
# Music
music_name = MUSIC_LOCATIONS['tracks'][self.settings_data['music']]
music_str = f'Music : {music_name}'
reset_pos = self.reset_button.rect.center
back_pos = self.back_button.rect.center
music_position = (reset_pos[0] + back_pos[0]) // 2, \
(reset_pos[1] + back_pos[1]) // 2
self.music_button = Button(self.screen, music_str, music_position,
self.changeMusic, 20, (256, 64))
def compileMenu(self):
# Menu
self.settings_menu = Menu(self.screen, self.title, False,
self.left_button, self.right_button,
self.jump_button, self.attack_button,
self.level_button, self.back_button,
self.reset_button, self.music_button)
def makeMenu(self):
# Title
self.title = Text(self.screen, (self.mid, self.height_unit), 40,
'Settings', 'purple')
self.makeNormalButtons()
self.makeMusicButton()
self.compileMenu()
def runSettings(self):
# load clock
clock = pygame.time.Clock()
while self.run:
clock.tick(self.max_fps)
# Get/action events
for event in pygame.event.get():
# Send each event to the start menu
if event.type == pygame.QUIT:
# Detecting user pressing quit button, if X pressed,
# break loop and quit screen.
self.run = False
elif (event.type == pygame.KEYDOWN):
if (event.key == pygame.K_ESCAPE):
self.run = False
elif self.changing[0]:
#print(settings_data[changing[1]])
#print(pygame.key.name(event.key))
new_key = pygame.key.name(event.key)
if new_key not in self.used_keys:
self.settings_data[self.changing[1]] = new_key
self.saveSettings()
self.refreshTexts()
elif (event.type == pygame.MOUSEBUTTONDOWN) or \
(event.type == pygame.MOUSEBUTTONUP):
button_press = self.settings_menu.do(event)
#print(button_press)
if button_press in self.texts.keys():
if button_press != self.changing[1]:
if self.changing[1] != None:
# If previously have had selection
self.texts[self.changing[1]].colour = 'white'
self.changing = (True, button_press)
self.texts[button_press].colour = 'red'
elif self.changing[1] == button_press:
# Unsets if same
self.texts[self.changing[1]].colour = 'white'
self.changing = (False, None)
# Display Pause Menu
self.screen.fill('black')
self.settings_menu.display()
for key in self.texts.keys():
self.texts[key].display()
pygame.display.flip()
def pauseScreen(screen, controller):
''' Pause Screen function
Produces the pause screen and allows interaction with buttons.
'''
height = screen.get_height()
width = screen.get_width()
height_unit = height // 3
mid_x, mid_y = width // 2, height // 2
menu_height = 3 * height // 4
width_unit = width // 6
# Setup menu and buttons
paused_text = Text(screen, (mid_x, height_unit), 60, 'PAUSED', 'purple')
resume_button = Button(
screen,
'Resume',
(width_unit, 2 * height_unit),
(lambda : 'resume'),
20,
(192, 64)
)
main_menu_button = Button(
screen,
'Main Menu',
(3 * width_unit, 2 * height_unit),
(lambda : 'main_menu'),
18,
(192, 64)
)
quit_button = Button(
screen,
'Quit',
(5 * width_unit, 2 * height_unit),
quitGame,
20,
(192, 64)
)
pause_menu = Menu(screen, paused_text, False, resume_button,
main_menu_button, quit_button)
# load clock
clock = pygame.time.Clock()
paused = True
while paused:
clock.tick(controller.clock_delay)
# Get/action events
for event in pygame.event.get():
# Send each event to the menu
if event.type == pygame.QUIT:
# Detecting user pressing quit button, if X pressed,
# break loop and quit screen.
paused = False
elif (event.type == pygame.KEYDOWN) and \
(event.key == pygame.K_ESCAPE):
paused = False
# Here, we check whether the player has clicked the mouse,
# if they have, we pass the click into the pause menu and it
# processes the click. The button function returns a string
# 'resume' for resume game, or 'main_menu' to quit to main
# menu.
elif (event.type == pygame.MOUSEBUTTONDOWN) or \
(event.type == pygame.MOUSEBUTTONUP):
button_press = pause_menu.do(event)
#print(button_press)
if button_press == 'resume':
paused = False
elif button_press == 'main_menu':
controller.run = False
paused = False
# Display Pause Menu
pause_menu.display()
pygame.display.flip()