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 game(self, filename): formosa = TiledRenderer(filename) run = True while run: try: event = pygame.event.wait() if event.type == KEYDOWN: arrow_pressed = False if (event.key == K_LEFT): angus.update(DIR_LEFT) arrow_pressed = True # KEY RIGHT if (event.key == K_RIGHT): angus.update(DIR_RIGHT) arrow_pressed = True # KEY UP if (event.key == K_UP): angus.update(DIR_UP) arrow_pressed = True # KEY DOWN if (event.key == K_DOWN): angus.update(DIR_DOWN) arrow_pressed = True if arrow_pressed and angus.collidelist(formosa.boxcollider) == -1: angus.move() if (event.key == K_ESCAPE): menu = Menu(screen, team, bag) run = menu.open_menu() if event.type == QUIT: run = False except KeyboardInterrupt: run = False formosa.terrain_render(screen_buf) formosa.over_terrain_render(screen_buf) formosa.under_char_render(screen_buf) screen_buf.blit(angus.image,angus.position) formosa.over_char_render(screen_buf) pygame.transform.scale(screen_buf, screen.get_size(), screen) pygame.display.flip() clock.tick(60)
def __init__(self, enemies): self.party = party # Could also just modify party itself, maybe self.enemies = enemies # Should be array of Enemy objects self.y = 0 # The battle area of the screen should have scrolling text as it gets filled up # No idea how to implement that s.set_state('battle') battle_text[self.y] = "A battle has begun!" # The battle loop self.print_battle_status() self.y += 2 battle_text[self.y] = "What will " + self.party[0].name + " do?" self.y += 1 s.cur_menu = Menu(["Blah 1", "Blah 2"], 1, []) menu_text = s.cur_menu.battle_menu() for line in menu_text: self.y += 1 battle_text[self.y] = line
font_size['title'], menu_title, 'purple') play_button = Button(menu_screen, play_text, (1 * width_unit, height_unit), playGame, 35, major_button_dims) settings_button = Button(menu_screen, settings_text,(3 * width_unit, height_unit), runSettings, 30, major_button_dims) about_button = Button(menu_screen, about_text, about_position, loadAbout, 30) quit_button = Button(menu_screen, quit_text, (5 * width_unit, height_unit), quitGame, 35, major_button_dims) # Initialising StartMenu class start_menu = Menu(menu_screen, title_obj, menu_background, play_button, settings_button, about_button, quit_button) # Start Music 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
from classes.menu import Menu menu=Menu() menu.imprimirMenu()
""" The Oyster Card Problem - This is a fare card system which is a limited version of London’s Oyster card system. - The user has a card with £30 balace initially. - Balance is deducted after every trip. To run it from a Mac: - Open a Terminal window. - Navigate to oyster_card folder. - type python3 main.py Note: you have to have python 3 installed main.py is just the main file that will call functions from the classes - Then the software will guid you through the menu Written by Hussain Alhassan on April 6, 2019 """ from classes.menu import Menu menu_obj = Menu() menu_obj.main_menu()
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()
""" Run the program """ from classes.menu import Menu Menu()
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 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()
import pygame from pygame.constants import MOUSEBUTTONDOWN from classes.game import Game from classes.menu import Menu from classes.credits import Credits from classes.highscore import Highscore from classes.choseHighscore import ChoseHighscore # Instanciations obligatoires initiales pygame.init() pygame.display.set_caption("Farmer in deep doo-doo") screen = pygame.display.set_mode((1024, 768)) pygame.display.set_icon(pygame.image.load('assets/character/charFront.png')) game = Game() menu = Menu() highscore = Highscore() choseHighscore = ChoseHighscore() credits = Credits() currentEvent = None running = True clock = pygame.time.Clock() music = False while running: clock.tick(60) if game.is_playing: # Si on est en jeu, on lance la boucle du jeu game.drawJeu(screen, pygame.display) game.catch_signal(screen, choseHighscore, currentEvent) currentEvent = None game.pressed["Clic"] = False elif credits.is_credits: # Si on est dans les crédits, on affiche les crédits
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()