def main_loop(self): while 1: #set fps self.clock.tick(60) #if the desired mode is changed, then change the program to that mode. if self.selected_mode != str(self.current_mode): if self.selected_mode == 'Start' or self.selected_mode == 'Continue': if self.save == None: self.save = Game(self.screen) self.current_mode = self.save elif self.selected_mode == 'Menu': if self.save == None: self.current_mode = Menu(['Start','Quit'],self.screen) else: self.current_mode = Menu(['Continue','Quit'],self.screen) elif self.selected_mode == 'Shop': temp = Shop(self.screen,self.save.player) self.current_mode = temp self.save.player = temp.player elif self.selected_mode == 'Quit': raise SystemExit #if the current_mode exist, run its loop if self.current_mode != None: #the loop usually returns a str(self), so when it is not the case, the mode changes self.selected_mode = self.current_mode.loop(pygame.event.get(),self.screen) pygame.display.flip()
def add_likelihood(self): pdf = self.choose_pdf() if pdf is not None: if len(self.history['likelihoods']) > 0: lk_history = sorted(self.history['likelihoods'], key=lambda x: x[1], reverse=True) sort_indices = sorted(range(len(self.history['likelihoods'])), key=lambda i: \ self.history['likelihoods'][i][1], reverse=True) options = [lk[0] for lk in lk_history] details = ['Likelihoods:\n' + '\n'.join( [' ' + s + ': ' + str(lk[2][s]) \ for s in sorted(lk[2].keys())]) \ for lk in lk_history] m = Menu(options=options, more=details, exit_str='New likelihood', header='Choose a likelihood function:\n' + \ '(add ? to the number to get ' + \ 'more info on a likelihood)') m.get_choice() if m.choice == m.exit: new_lk = self.define_new_likelihood(pdf) pdf.add_likelihood(new_lk[0], **new_lk[2]) else: self.history['likelihoods'][sort_indices[m.i_choice]][1] \ += 1 lk = self.history['likelihoods'][sort_indices[m.i_choice]] pdf.add_likelihood(lk[0], **lk[2]) else: new_lk = self.define_new_likelihood(pdf) pdf.add_likelihood(new_lk[0], **new_lk[2])
def change_plot(self): # options that apply to all subplots options = [('Change axis limits', self.plot.change_limits), ('Change axis labels', self.plot.label_axes), ('Add legend', self.plot.add_legend)] # change appearance of a PDF if self.pdf_exists(): options.extend([('Change constraint color', self.change_pdf_color)]) # options specific to 1D or 2D plots subplot_1d_exists = False subplot_2d_exists = False subplot_2d_has_multiple_contours = False for ax_row in self.plot.axes: for ax in ax_row: if hasattr(ax, 'parameters'): if len(ax.parameters) == 1: subplot_1d_exists = True elif len(ax.parameters) == 2: subplot_2d_exists = True if len(ax.pdfs) > 1: subplot_2d_has_multiple_contours = True if subplot_2d_has_multiple_contours: options.extend([('Change order of contour layers', self.plot.change_layer_order)]) options = OrderedDict(options) m = Menu(options=options.keys(), exit_str='Cancel') m.get_choice() if m.choice != m.exit: options[m.choice]() #self.plot.plot_grid.tight_layout(self.plot.figure) self.plot.figure.set_tight_layout(True) plt.draw()
def delete_history(self): m = Menu(options=['Likelihoods', 'Chains', 'All'], exit_str='Cancel') m.get_choice() if m.choice == 'Likelihoods' or m.choice == 'All': self.history['likelihoods'] = [] if m.choice == 'Chains' or m.choice == 'All': self.history['chains'] = []
def add_chain(self): pdf = self.choose_pdf(require_no_chain=True) # select from list of currently defined chains (from all pdfs), # previously used chains (read from file), # or get files and name for new chain (if new, save to file) if pdf is not None: if len(self.history['chains']) > 0: chain_history = sorted(self.history['chains'], key=lambda x: x[0], reverse=True) sort_indices = sorted(range(len(self.history['chains'])), key=lambda i: \ self.history['chains'][i][0], reverse=True) options = [ch[1] for ch in chain_history] details = ['Chains:\n' + '\n'.join( [textwrap.fill(s, initial_indent=' ', subsequent_indent=' ') \ for s in sorted(ch[2])]) \ for ch in chain_history] m = Menu(options=options, more=details, exit_str='New chain', header='Choose a chain:\n' + \ '(add ? to the number to get ' + \ 'more info on a chain)') m.get_choice() if m.choice == m.exit: pdf.add_chain(*self.define_new_chain()) else: self.history['chains'][sort_indices[m.i_choice]][0] += 1 pdf.add_chain(*self.history['chains'] \ [sort_indices[m.i_choice]][1:]) else: pdf.add_chain(*self.define_new_chain())
def show_menu(self, command, options): """Shows the tab-completion menu""" menu = Menu(self.win, options ) option = menu.run() menu.hide() if option is not None: self.set_buffer(command + ' ' + option)
def test_single_options_single_digits(self): m = Menu(test_contacts) assert len(m.get_options('2')) == 1 assert m.get_options('2')[0]['number'] == '1' assert len(m.get_options('3')) == 1 assert m.get_options('3')[0]['number'] == '2'
def get_modification(self):#integrate options, perhaps send to 'get' functions and change those to file mods choice = None resume = False while choice != 'q': if self.mod_key == "Resume": # if self.mod_value != None: # print("\n\t\tHere is the current resume.") # resume = self.controller.get_resume(self) # self.open_resume(resume) # choice = input("Please enter the new resumes file path\nand file name with a .pdf ending: ") # resume = self.save_resume(choice) # new_value = choice print("\n\t\tResume saving inside database is currently malfunctioning, pick another option please.") time.sleep(4) break else: print("\n\t\tYou have chosen to modify '{}'.\n".format(self.mod_key)) print("\nOpening contents in text editor. Please modify and save the file.") self.open_data() new_value = None choice = input("\n\t\tPress enter to continue when ready...") if not new_value: new_value = self.save_data() Menu.clear_screen() print("\nThe information you have entered is:\n{}".format(new_value)) verify = input("Is this correct? 'y' to confirm: ").lower() if Menu.verify_yes_no(verify): print("\nEntry complete and saving now.") if resume: self.info[self.mod_key] = resume.encode('utf8') else: self.info[self.mod_key] = new_value choice = 'q' time.sleep(2) return resume
def main(): #Initialize pygame.init() screen = pygame.display.set_mode((width, height)) pygame.display.set_caption(WINDOW_TITLE) screen.fill(bg_color) clock = pygame.time.Clock() font = pygame.font.Font(font_path, fonth) img_reglas = load_image(reglas_path) img_creditos = load_image(creditos_path) pygame.mixer.music.load(menu_music) pygame.mixer.music.play() while True: menu = Menu(screen, font, ['Jugar', 'Reglas', 'Creditos', 'Salir']) op = menu.main_loop() if op == 0: game = SC(screen, clock) game.main_loop() elif op == 1: SimpleScreen(screen, img_reglas).main_loop() elif op == 2: SimpleScreen(screen, img_creditos).main_loop() elif op == 3: sys.exit(0)
def mode__episodes(self): id = self.args['id'][0] menu = Menu(self.base_url, self.addon_handle) for item in a3media.get_episodes(id): video = {"Plot": item['plot']} menu.add(MenuItem(item['title'], 'play', args={'id': id}, iconImage=item['img'], video=video)) menu.show()
def mode__section(self): id = self.args['id'][0] menu = Menu(self.base_url, self.addon_handle) for item in a3media.get_section(id): video = {"Plot": item['plot']} menu.add(MenuItem(item['title'], 'subcategories', args={'id': id, 'subid': item['id']}, iconImage=item['img'], video=video)) menu.show()
def test_select_parents(self): """ Ensure the MENU_SELECT_PARENTS setting works """ settings.MENU_SELECT_PARENTS = False request = self.factory.get('/parent2/kids2-1') items = Menu.process(request, 'test') self.assertEqual(items[0].selected, True) self.assertEqual(items[0].children[1].selected, True) self.assertEqual(items[1].selected, False) request = self.factory.get('/kids2-2') items = Menu.process(request, 'test') self.assertEqual(items[0].selected, False) self.assertEqual(items[0].children[0].selected, True) self.assertEqual(items[1].selected, False) settings.MENU_SELECT_PARENTS = True request = self.factory.get('/kids2-2') items = Menu.process(request, 'test') self.assertEqual(items[0].selected, True) self.assertEqual(items[0].children[0].selected, True) self.assertEqual(items[1].selected, False) request = self.factory.get('/parent3/kids3-1/kid1') items = Menu.process(request, 'test') self.assertEqual(items[0].selected, False) self.assertEqual(items[0].children[1].selected, False) self.assertEqual(items[1].selected, True) self.assertEqual(items[1].children[0].selected, True) self.assertEqual(items[1].children[0].children[0].selected, True) self.assertEqual(items[1].children[1].selected, False) self.assertEqual(items[2].selected, False)
def build_shows_menu(self, shows): menu = Menu(self.base_url, self.addon_handle) for show in shows: iconImage = show.img if len(show.img) > 0 else 'DefaultVideo.png' li = MenuItem(show.title, 'episodes', args={'code': show.code}, iconImage=iconImage) menu.add(li) menu.show()
def test_display_select_setting_name_modify_attributes_should_update_attribute_for_level(self): sudoku_menu = Menu() sudoku_setting = Settings() old_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max") sudoku_menu.display_select_setting_name_to_modify_attributes("Level") new_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max") self.assertEqual(old_value, new_value)
def change_layer_order(self, ax=None): if ax is None: ax = self.select_subplot() set_pdfs = self.settings['{0:d}.{1:d}'.format(ax.row, ax.col)]['pdfs'] # find current order pdfs = [] layers = [] for pdf in set_pdfs: if 'layer' in set_pdfs[pdf]: layers.append(set_pdfs[pdf]['layer']) pdfs.append(pdf) old_layers = list(zip(*sorted(zip(pdfs, layers), key=lambda x: x[1], reverse=True))[0]) # get new order (e.g. 1 0 2) m = Menu(options=old_layers, exit_str=None, header='Enter a new order for the constraints.\n' + \ 'The current order (top to bottom) is:') new_layer_order = m.get_order() new_layer_order.reverse() # should clear subplot before plotting contours again, # but don't want to change other plot elements # re-plot pdfs in new order for i in new_layer_order: self.plot_2d_pdf(ax, ax.pdfs[old_layers[i]], layer=-1)
def main(): """Snake main entry point.""" pygame.init() game_display = display.Display('Snake') # Create menu buttons menu_buttons = [Button("(1) Classic game", (display.WINDOW_WIDTH * 1/3, display.WINDOW_HEIGHT * 3/8), pygl.K_1), Button("(2) Exit", (display.WINDOW_WIDTH * 1/3, display.WINDOW_HEIGHT * 4/8), pygl.K_2)] # Create the menu game_menu = Menu(game_display, menu_buttons, 'snake/images/menu/snake.png') game_menu.draw() while True: for event in pygame.event.get(): if (event.type == pygl.QUIT) or \ (event.type == pygl.KEYDOWN and event.key == pygl.K_ESCAPE): sys.exit(pygame.quit) for button in menu_buttons: if (event.type == pygl.KEYDOWN and button.key_pressed(event.key)): run_game(game_display) pygame.display.update() game_display.update_clock()
def connectHandlers(self): # Inherited connections. Menu.connectHandlers(self) # Specific connections. self.btnBack.subscribeEvent(PyCEGUI.PushButton.EventClicked, self, "onBackButtonClicked")
def quit_game(): quit_items=Menu([ MenuItem(1, "Save and Quit", save_and_quit), MenuItem(2, "Quit without save", quit_without_save), MenuItem(3, "Resume", resume)]) quit_items.print_menu_items() quit_item=quit_items.select_menu_item()
def potion_submenu(): potion_submenu_items=Menu([ MenuItem(1, "Reselect the Potion", select_potion), MenuItem(2, "Continue", print_character), MenuItem(3, "Quit", quit_game)]) potion_submenu_items.print_menu_items() potion_submenu_item=potion_submenu_items.select_menu_item()
def ready(self): # Add two items to our main menu Menu.add_item("main", MenuItem("Informacje o koncie",reverse("am_userInfo"),weight=10,icon="tools")) Menu.add_item("main", MenuItem("zmień dane",reverse("am_changeUserdata"),weight=20,icon="report")) Menu.add_item("main", MenuItem("zmień hasło",reverse("am_changeUserpassword"),weight=30,icon="report")) Menu.add_item("main", MenuItem("twoje ankiety",reverse("am_userSurveys"),weight=40,icon="report")) Menu.add_item("main", MenuItem("statystyki i aktywność użytkownika",reverse("am_userActivity"),weight=50,icon="report"))
def __init__(self,screen): # Load images global images images = loadImages() #Load sounds Effects global sounds sounds = loadSounds() # Ojbects self.player = Player((93,324),images,sounds) self.playerSprite = pygame.sprite.Group() self.playerSprite.add(self.player) # ------------------- self.levelList = [] self.levelList.append(niveles.Level_One(images,sounds,self.player)) self.levelList.append(niveles.Level_Two(images,sounds,self.player)) self.currentLevel = 0 self.level = self.levelList[self.currentLevel] self.level.load_music() self.player.level = self.level #-------------------------------------------------------------- self.text_font = pygame.font.Font("fuentes/FreeSansBold.ttf",38) #Create menu object: self.menu = Menu(screen,("INICIO","OPCIONES","AYUDA","SALIR"),ttf_font="fuentes/dejavu.ttf", font_color=(0,0,0),bg_image=images["intro"],font_size=34) self.menuPausa = Menu(screen,("Continuar Juego","Menu prinsipal"),ttf_font="fuentes/dejavu.ttf", font_color=(0,0,0),bg_image=images["background"],font_size=34) self.screen = screen
def play(): from menu import Menu menu = Menu(screen) #show menu before starting game. menu.showMenu() from player import Player from bullet import Bullet from enemies import Enemies player = Player() player.set_screen(screen) to_update = player.create() #draw player to screen immediately pygame.display.update(to_update) bullet = Bullet() bullet.set_screen(screen) enemies = Enemies() enemies.set_screen(screen) while player.is_alive(): to_update = [] pygame.event.pump() key = pygame.key.get_pressed() #key events that only need to be pressed once for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: menu.showMenu() if event.key == pygame.K_SPACE: player.fire(bullet, True) if key[pygame.K_ESCAPE]: sys.exit() if key[pygame.K_RIGHT]: to_update += player.move_right() if key[pygame.K_LEFT]: to_update += player.move_left() if key[pygame.K_SPACE]: player.fire(bullet, False) frametime.start() to_update += bullet.move(enemies, player) to_update += enemies.move(bullet) pygame.display.update(to_update) #find how long it took to render this frame so we can adjust speeds frametime.end() #player died player.game_over() enemies.game_over() bullet.game_over() pygame.display.flip()
def main(): menu = Menu() f = None experiments = import_module("experiments").__all__ for exp_name in experiments: if exp_name.startswith("*"): f = exp_name break if not f: f = menu.experiments_prompt() curr_exp = Current_experiment(import_module("experiments." + f)) arduino = arduino_serial.Arduino(serial_name = curr_exp.serial_name) arduino.start() scheduler = Scheduler(curr_exp) controller = Controller(curr_exp, scheduler.schedule_a, scheduler.schedule_b, scheduler.schedule_mat) controller.send_scheduled_commands() tagger = Data_handler(curr_exp, scheduler.schedule_a, scheduler.schedule_b) previous_time = datetime.now() running = True while running: try: if (datetime.now() - previous_time).total_seconds() > 5: controller.send_scheduled_commands() previous_time = datetime.now() tagger.ard_grab_and_tag_data(arduino) except KeyboardInterrupt: running = False
def test_select_shouldShowLoadingWhileGettingItemsAsynchronously(): asyncFolder = mocks.NeverLoadingFolder("Dynamic", []) dynamicMainFolder = mocks.Folder("Main", [asyncFolder]) menu = Menu(dynamicMainFolder) menu.select() assert asyncFolder.loadItemsCnt == 0 assert menu.item() is menu._loadingItem
def test_select_shouldLoadAsyncFolders(): asyncFolder = mocks.SynchronAsyncFolder("Dynamic", []) dynamicMainFolder = mocks.Folder("Main", [asyncFolder]) menu = Menu(dynamicMainFolder) menu.select() assert asyncFolder.loadItemsCnt == 1 assert menu._currentItems == asyncFolder._itemsToLoad
def albums_action(menuitem, gui, artist_id = None): """ Load the list of artists from the XBMC and display the menu. """ if artist_id: result = xbmc.call.AudioLibrary.GetAlbums(artistid = artist_id) else: result = xbmc.call.AudioLibrary.GetAlbums() def convert(album): text = album["label"] if album.has_key('thumbnail'): pass #image = self.cache.open_http( # album["thumbnail"], self.config["default album"], # image_convert) else: image = self.cache.open(self.config["default album"]) def action(menuitem2, gui2): tracks_action(menuitem2, gui2, album["albumid"]) return MenuItem(image, text, action) self.albums_menu.fill(*map(convert, result["albums"])) Menu.action_helper(self.albums_menu)(menuitem, gui)
def __init__(self, app): Menu.__init__(self, app) self.header = ["Ebenezer personal accounting ver 0.1",\ "-----------[ Main menu ]------------"] num_acc = len(data.accounts) if self.app.active_account is None: active_account_name = "No account found!" else: active_account_name = self.app.active_account.name self.contents = ["Found " + str(num_acc) + " data.accounts",\ "Current active account : " + active_account_name,\ "[A]ccounts",\ "[T]ransactions",\ "[D]ebts",\ "[Q]uit"] self.prompt = "What do you want to do ?" self.answers = {"a":[self.change_menu, "accountlist"],\ "t":[self.change_menu, "accounttrans"],\ "d":[self.change_menu, "debts"],\ "q":[self.quit, None]}
def show_menu(self): from menu import Menu import Tkinter as tk root = tk.Tk() self.add_human = 0 self.goOn = 0 def set_AI_vs_human(): self.add_human = 1 root.destroy() self.goOn = 1 def set_AI_vs_AI(): root.destroy() self.goOn = 1 def quit(): root.destroy() items = [("AI vs Human", set_AI_vs_human), ("AI vs AI", set_AI_vs_AI), ("Quit", quit)] menu = Menu(root, items) menu.pack() root.mainloop() if not self.goOn: self.quit() else: del self.goOn
def strike_menu(): roll_cube(player) roll_cube(opponent) if player.roll > opponent.roll: print(player) print(opponent) print('You hits monster') opponent.hp -= 2 print(player) print(opponent) else: print(player) print(opponent) print('Monster hits you') player.hp -= 2 print(player) print(opponent) name_items = Menu([ MenuItem(1, 'Try your luck', try_your_luck_menu), MenuItem(2, 'Retreat', strike_menu), MenuItem(3, 'Quit', quit), ]) name_items.print_menu() name_items.choose()
def start(self): pygame.display.flip() menu = Menu(self.fenetre) askToExit = False while not askToExit: for event in pygame.event.get(): if event.type == QUIT: askToExit = True if event.type == KEYDOWN: if event.key == K_ESCAPE: askToExit = True choix = menu.loop() if choix <=0: askToExit = True if choix == 4: regle = Regle(self.fenetre) regle = regle.loop() if regle <=0: askToExit = True if choix == 1: niveau = Niveau(1) joueurs = [Joueur(1),Joueur(1)] partie = Partie(self.fenetre,niveau,joueurs) askToExit = partie.start() Joueur.i = 1
from req import Request from menu import Menu requisicao = Request() menu = Menu() INTERVALO_NAO_ZERO_OU_NEGATIVO = 0 VOLTAR = 9 class Moedas: def escolha_menu(self, option: int): self.option = option escolha_dic = { 0: lambda temp: self.escolhas_moeda(self.tmp_moeda), 1: lambda temp: self.escolhas_moeda_intervalo(self.tmp_moeda), } if self.option not in escolha_dic.keys(): raise KeyError else: print(menu.mostra_moedas_menu()) self.tmp_moeda = int(input('Escolha:')) if self.tmp_moeda == VOLTAR: return '' else: return escolha_dic[self.option](self.tmp_moeda) def escolhas_moeda(self, entrada_tipo_moeda: int): self.moeda = entrada_tipo_moeda self.tmp_moeda = '' self.moeda_dic = {
# -*- coding: utf-8 -*- from menu import Menu if __name__ == "__main__": lista_personas = [] menu = Menu(lista_personas) menu.iniciar()
from menu import Menu from boardFunctions import BoardFunctions myGame = Menu() myGame.game_menu() myBoard = BoardFunctions() size = myGame.board_size mines = myGame.mines_num myBoard.mines_num = mines grid = myBoard.make_grid(size) myBoard.generate_mines(size, grid) myBoard.just_print(size, grid) myBoard.print_board(size, grid) # myGame.play_game()
class Game(): def __init__(self, screen, clk): self.heart_image = pygame.image.load('source\\heart.png') self.heart_empty_image = pygame.image.load('source\\heart_empty.png') self.hero_image = pygame.image.load('source\\TEMP_medic.png') self.black_image = pygame.image.load('source\\blackground.jpg') self.red_image = pygame.image.load('source\\redground.png') self.background_image = pygame.image.load( 'source\\menu_background.jpg').convert() self.mouse_image = pygame.image.load('source\\broadsword.png') self.divide_image = pygame.image.load('source\\border_vertical.png') self.ring_image = pygame.image.load('source\\ring.png') self.welBk_image = pygame.image.load('source\\welcome_bk.png') self.skeleton_static = pygame.image.load('source\\skeleton_static.png') self.slime_green_static = pygame.image.load( 'source\\slime_green_static.png') self.slime_blue_static = pygame.image.load( 'source\\slime_blue_static.png') self.spider_static = pygame.image.load('source\\spider_static.png') self.gameover = pygame.image.load('source\\game_over.png') self.mouse_cursor = pygame.transform.scale(self.mouse_image, (30, 30)) self.font1 = pygame.font.Font('source\\Font Error.ttf', 18) self.font2 = pygame.font.Font('source\\Song.ttf', 35) self.font3 = pygame.font.Font('source\\Font Error.ttf', 35) self.menu = Menu(('START', 'HELP', 'EXIT')) self.font_text1 = self.font1.render('Won\'t move', True, WHITE) self.font_text2 = self.font1.render('Move up & down', True, WHITE) self.font_text3 = self.font1.render('Square movement', True, WHITE) self.font_text4 = self.font1.render('Sloping movement, ', True, WHITE) self.useless = [] self.state = 6 #welcome self.screen = screen self.menu = Menu(('START', 'HELP', 'EXIT')) self.map = Map(self.screen) self.move = False self.pos_x, self.pos_y = 4, 4 self.groups = sprite.Groups(screen, self.map) self.clk = clk self.attacked = True self.last_time = 0 self.beats_time_mod = [] self.modified_beats = [] self.lives = 3 self.lv = 1 self.swipe = sprite.Animation(self.screen, 'source\\swipe_dagger.png', 3) self.swipe_group = pygame.sprite.Group() self.swipe_group.add(self.swipe) def game_quit(self): pygame.quit() exit() def selection(self): print(self.menu.state) def update_frame(self): common_function.check_return() '''Creat Background''' self.screen.blit(self.background_image, (0, 0)) '''Creat Mouse Cursor ''' x, y = pygame.mouse.get_pos() x -= self.mouse_cursor.get_width() / 2 y -= self.mouse_cursor.get_height() / 2 self.screen.blit(self.mouse_cursor, (x, y)) def update_menu_frame(self): common_function.check_return() '''Creat Background''' self.screen.blit(self.background_image, (0, 0)) '''Creat Menu''' self.menu.update() self.menu.display_frame(self.screen) '''Creat Mouse Cursor ''' x, y = pygame.mouse.get_pos() x -= self.mouse_cursor.get_width() / 2 y -= self.mouse_cursor.get_height() / 2 self.screen.blit(self.mouse_cursor, (x, y)) def update_game_frame(self): common_function.check_return() '''Display Background''' self.screen.blit(self.black_image, (0, 0)) '''Draw Hero's POS''' rectx, recty = OFFSET_X + self.pos_x * BLOCK, OFFSET_Y + self.pos_y * BLOCK + BLOCK / 2 sqr = pygame.draw.rect(self.screen, YELLOW, (rectx, recty, 60, 60)) '''Draw the map''' self.map.display_map() '''Creat Mouse Cursor ''' x, y = pygame.mouse.get_pos() x -= self.mouse_cursor.get_width() / 2 y -= self.mouse_cursor.get_height() / 2 self.screen.blit(self.mouse_cursor, (x, y)) '''Display Divide''' self.screen.blit(self.divide_image, (580, 0)) '''Display Lv inf''' self.display_Lv() '''Display Lives''' if self.lives == 3: for i in range(3): self.screen.blit(self.heart_image, (LIVES_LEGEND + i * 50, 15)) elif self.lives == 2: self.screen.blit(self.heart_image, (LIVES_LEGEND + 0 * 50, 15)) self.screen.blit(self.heart_image, (LIVES_LEGEND + 1 * 50, 15)) self.screen.blit(self.heart_empty_image, (LIVES_LEGEND + 2 * 50, 15)) elif self.lives == 1: self.screen.blit(self.heart_image, (LIVES_LEGEND + 0 * 50, 15)) self.screen.blit(self.heart_empty_image, (LIVES_LEGEND + 1 * 50, 15)) self.screen.blit(self.heart_empty_image, (LIVES_LEGEND + 2 * 50, 15)) else: for i in range(3): self.screen.blit(self.heart_empty_image, (LIVES_LEGEND + i * 50, 15)) '''Display monster images''' self.screen.blit(self.slime_green_static, (MONSTER_LEGEND, 220)) self.screen.blit(self.slime_blue_static, (MONSTER_LEGEND, 320)) self.screen.blit(self.spider_static, (MONSTER_LEGEND, 420)) self.screen.blit(self.skeleton_static, (MONSTER_LEGEND, 520)) '''Display monster information''' self.screen.blit(self.font_text1, (TEXT_LEGEND, 240)) self.screen.blit(self.font_text2, (TEXT_LEGEND, 340)) self.screen.blit(self.font_text3, (TEXT_LEGEND, 440)) self.screen.blit(self.font_text4, (TEXT_LEGEND, 540)) '''check beat''' clk = pygame.mixer.music.get_pos() if int(clk / 10) in self.beats_time_mod or int( clk / 10) + 1 in self.beats_time_mod or int( clk / 10) - 1 in self.beats_time_mod: if int(clk / 10) in self.beats_time_mod: self.beats_time_mod.remove(int(clk / 10)) elif int(clk / 10) + 1 in self.beats_time_mod: self.beats_time_mod.remove(int(clk / 10) + 1) else: self.beats_time_mod.remove(int(clk / 10) - 1) #print(int(clk/10)) self.move = True '''Display Monsters''' ticks = pygame.time.get_ticks() # Give gif clk self.groups.monster_group.update(ticks, 0, 0, self.move) self.move = False self.groups.monster_group.draw(self.screen) '''Check and display attacked''' self.check_attacked() if self.attacked: self.screen.blit(self.red_image, (0, 0)) if pygame.time.get_ticks() > self.last_time + 500: self.attacked = False '''Display Hero''' self.screen.blit(self.ring_image, (rectx, recty + 10)) self.groups.hero_group.update(ticks, self.pos_x, self.pos_y) self.groups.hero_group.draw(self.screen) if self.swipe.visable: self.swipe_group.update(ticks) self.swipe_group.draw(self.screen) def display_Lv(self): lv = 'LEVEL ' + str(self.lv) label = self.font3.render(lv, True, YELLOW) width = label.get_width() height = label.get_height() pos_x = 800 - 20 - width pos_y = 80 self.screen.blit(label, (pos_x, pos_y)) ''' STATE: 1 MENU 2 START 3 HELP 4 EXIT 5 GAME OVER 6 WELCOME 0 GAME RUNNING ''' def state_logic(self): if self.state == 0: self.show_game_process() return False elif self.state == 1: self.show_menu() return False elif self.state == 2: self.show_game() return False elif self.state == 3: self.show_help() return False elif self.state == 4: return True elif self.state == 5: self.display_gameover() elif self.state == 6: self.welcome() def welcome(self): text = self.font2.render("(按任意键以继续)", True, WHITE, BLACK) ztx, zty, ztw, zth = text.get_rect() jx = pygame.Rect(800, 200, ztw, zth) clock = pygame.time.Clock() txt1 = self.font2.render("一名探险家偶然踏入一座地牢,神奇的是: ", True, WHITE, BLACK) txt2 = self.font2.render("这座地牢的里的怪物们会根据音乐节奏移动。", True, WHITE, BLACK) txt3 = self.font2.render("小心移动并击杀怪物,逃出地牢···", True, WHITE, BLACK) self.screen.fill((0, 0, 0)) self.screen.blit(self.welBk_image, (100, 300)) self.screen.blit(txt1, (50, 50)) self.screen.blit(txt2, (50, 150)) self.screen.blit(txt3, (50, 250)) pygame.display.update() time.sleep(3) while True: self.screen.fill((0, 0, 0)) self.screen.blit(self.welBk_image, (100, 300)) clock.tick(30) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() exit(0) if event.type == pygame.KEYDOWN: self.state = 1 return elif event.type == pygame.MOUSEBUTTONDOWN: self.state = 1 return jx.x -= 5 if jx.x < 0 - ztw: jx.x = 510 self.screen.blit(text, [jx.x, jx.y]) pygame.display.update() def show_menu(self): for event in pygame.event.get(): if event.type == pygame.QUIT: self.game_quit() if event.type == pygame.KEYDOWN: if event.type == K_ESCAPE: self.game_quit() elif event.type == pygame.MOUSEBUTTONDOWN: mouse_x, mouse_y = pygame.mouse.get_pos() if self.menu.rect_list[0].collidepoint(mouse_x, mouse_y): self.state = 2 elif self.menu.rect_list[1].collidepoint(mouse_x, mouse_y): self.state = 3 elif self.menu.rect_list[2].collidepoint(mouse_x, mouse_y): pygame.quit() exit() else: self.state = 1 self.update_menu_frame() pygame.display.flip() def display_message(self, message): label = self.font2.render(message, True, WHITE) width = label.get_width() height = label.get_height() pos_x = (SCREEN_WIDTH // 2) - (width // 2) pos_y = (SCREEN_HEIGHT // 2) - (height // 2) self.screen.blit(label, (pos_x, pos_y)) def show_help(self): for event in pygame.event.get(): if event.type == QUIT: self.game_quit() if event.type == KEYDOWN: if event.key == K_ESCAPE: print("Exit from help") self.state = 1 return self.update_frame() label1 = self.font2.render(" 使用←↑→↓移动 ", True, WHITE) label2 = self.font2.render("开始前选择地牢节奏", True, WHITE) label3 = self.font2.render("怪物将根据节奏移动", True, WHITE) label4 = self.font2.render("(按ESC回到主菜单)", True, WHITE) pos_x = 150 pos_y = 200 self.screen.blit(label1, (pos_x, pos_y)) self.screen.blit(label2, (pos_x, pos_y + 50)) self.screen.blit(label3, (pos_x, pos_y + 100)) self.screen.blit(label4, (pos_x + 100, pos_y + 300)) pygame.display.flip() def select_music(self): root = tkinter.Tk() root.withdraw() music_name = tkinter.filedialog.askopenfilenames() if len(music_name) != 0: music_name_str = '' for i in range(0, len(music_name)): music_name_str += str(music_name[i]) print(music_name_str) return music_name_str else: self.update_frame() self.display_message("Please select your music !") pygame.display.flip() self.select_music() def show_game(self): common_function.check_return() filename = self.select_music() pygame.display.flip() pygame.mixer.music.load(filename) pygame.mixer.music.set_endevent(pygame.USEREVENT + 1) '''Beat Track''' y, sr = librosa.load(filename) duration = librosa.get_duration(y) #print(duration) tempo, beats = librosa.beat.beat_track(y) amt = beats.size beats_time = librosa.frames_to_time(beats) # print(beats_time) self.beats_time_mod = [] for b in beats_time: self.beats_time_mod.append(int(b * 100)) self.state = 0 pygame.mixer.music.play(1, 0) self.show_game_process() def display(self): if self.state == 0: self.update_game_frame() else: self.update_frame() self.clk.tick(FRAME_RATE) def display_gameover(self): for event in pygame.event.get(): if event.type == QUIT: self.game_quit() if event.type == KEYDOWN: if event.key == K_ESCAPE: #print("Exit from gameover") self.state = 1 return #print('gameover') self.screen.blit(self.gameover, (0, 0)) label4 = self.font2.render("(按ESC回到主菜单)", True, WHITE) self.screen.blit(label4, (250, 500)) pygame.display.flip() def resetPos(self): for monster in self.groups.monster_group: #print(monster.pos_x, monster.pos_y) self.map.array[monster.pos_x][monster.pos_x] = 1 def readPos(self): self.map = Map(self.screen) for monster in self.groups.monster_group: #print(monster.pos_x, monster.pos_y) self.map.array[monster.pos_x][monster.pos_y] = 2 def removeMonster(self, pos_x, pos_y): for monster in self.groups.monster_group: if monster.pos_x == pos_x and monster.pos_y == pos_y: #print(pos_x, pos_y) self.map.array[pos_x][pos_y] = 1 self.groups.monster_group.remove(monster) def move_or_kill(self, factor_x, factor_y): if common_function.check_movable(self.pos_x + factor_x, self.pos_y + factor_y, self.map): '''Kill''' if self.map.array[self.pos_x + factor_x][self.pos_y + factor_y] == 2: self.swipe.set_pos(self.pos_x + factor_x, self.pos_y + factor_y) self.swipe.visable = True self.removeMonster(self.pos_x + factor_x, self.pos_y + factor_y) else: '''Move''' self.pos_x += factor_x self.pos_y += factor_y #self.move = True def check_attacked(self): self.readPos() #common_function.printMap(self.map) if self.map.array[self.pos_x][self.pos_y] == 2: '''Was attacked''' self.lives -= 1 if self.lives == 0: pygame.mixer.music.stop() self.__init__(self.screen, self.clk) self.state = 5 self.display_gameover() self.attacked = True self.last_time = pygame.time.get_ticks() flag = False while not flag: temp_x = common_function.get_randint(1, 8) temp_y = common_function.get_randint(1, 8) if self.map.array[temp_x][temp_y] == 1: self.pos_x = temp_x self.pos_y = temp_y flag = True def get_proper_pos(self): while True: temp_x = common_function.get_randint(1, 8) temp_y = common_function.get_randint(1, 8) if self.map.array[temp_x][temp_y] == 1: return temp_x, temp_y def add_characters_1(self): pos_x, pos_y = self.get_proper_pos() self.map.array[pos_x][pos_y] = 2 green_slime = character.Slime_Green(self.screen, pos_x, pos_y, self.map) self.groups.monster_group.add(green_slime) def add_characters_2(self): pos_x, pos_y = self.get_proper_pos() self.map.array[pos_x][pos_y] = 2 blue_slime = character.Slime_Blue(self.screen, pos_x, pos_y, self.map) self.groups.monster_group.add(blue_slime) def add_characters_3(self): pos_x, pos_y = self.get_proper_pos() self.map.array[pos_x][pos_y] = 2 spider = character.Spider(self.screen, pos_x, pos_y, self.map) self.groups.monster_group.add(spider) def add_characters_4(self): pos_x, pos_y = self.get_proper_pos() self.map.array[pos_x][pos_y] = 2 skeleon = character.Skeleon(self.screen, pos_x, pos_y, self.map) self.groups.monster_group.add(skeleon) def auto_add_monster(self): if self.lv == 2: self.add_characters_2() elif self.lv == 3: self.add_characters_3() elif self.lv == 4: self.add_characters_4() else: for i in range(self.lv - 4): raint = common_function.get_randint(1, 4) if raint == 1: self.add_characters_1() elif raint == 2: self.add_characters_2() elif raint == 3: self.add_characters_3() else: self.add_characters_4() def level_up(self): print("Level up") self.lv += 1 self.auto_add_monster() def show_game_process(self): for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() exit() if event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.mixer.music.stop() self.__init__(self.screen, self.clk) self.state = 1 return else: self.readPos() #common_function.printMap(self.map) if event.key == K_LEFT or event.key == K_a: self.move_or_kill(-1, 0) elif event.key == K_RIGHT or event.key == K_d: # 右方向键则加一 self.move_or_kill(+1, 0) elif event.key == K_UP or event.key == K_w: # 类似 self.move_or_kill(0, -1) elif event.key == K_DOWN or event.key == K_s: self.move_or_kill(0, +1) if not len(self.groups.monster_group): self.level_up() if event.type == pygame.USEREVENT + 1: print("Game Finished") self.state = 1 return pygame.display.flip()
class MainWindow(QMainWindow): def __init__(self): super().__init__() dockWidget = QDockWidget("Explorer", self) self.editor = QPlainTextEdit() self.editor.document().setDefaultFont(QFont("monospace")) self.editor.zoomIn(2) self.explorer = QTreeView() self.model = QFileSystemModel(self.explorer) self.root = self.model.setRootPath("../..") self.explorer.setModel(self.model) self.explorer.setRootIndex(self.root) self.file_path = None # Instances of menus and message self.custom_menu = Custom_menu(self, self.explorer, self.model, self.editor, app) self.menu = Menu(self, self.explorer, self.editor, self.model) self.message = Message(self) # Menu bar self.file_menu = self.menuBar().addMenu("&File") self.help_menu = self.menuBar().addMenu("&Help") self.menu.menu_actions() # Other custom tweaks self.explorer.setSortingEnabled(True) self.explorer.setMinimumWidth(400) self.explorer.setContextMenuPolicy(Qt.CustomContextMenu) self.resize(1500, 900) # Enabling renaming on context menu self.model.setReadOnly(False) self.explorer.setEditTriggers(self.explorer.NoEditTriggers) # Change default explorers column width self.header = self.explorer.header() self.header.setSectionResizeMode(0, QHeaderView.Interactive) self.header.setDefaultSectionSize(200) self.header.setSectionResizeMode(1, QHeaderView.ResizeToContents) self.header.setSectionResizeMode(2, QHeaderView.ResizeToContents) # Setting editor as central widget self.setCentralWidget(self.editor) self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget) # Setting view as widget of dock widget dockWidget.setWidget(self.explorer) dockWidget.setFloating(False) ### Double & right click self.explorer.doubleClicked.connect(self.custom_menu.on_double_click) self.explorer.customContextMenuRequested.connect( self.custom_menu.context_menu) def closeEvent(self, e): """This function prevents from closing without saving, it works with the "Close" event""" if not self.editor.document().isModified(): return answer = self.message.ask_for_confirmation() if answer == QMessageBox.Save: if not self.menu.save(): e.ignore() elif answer == QMessageBox.Cancel: e.ignore()
class Game: #Background Color BLACK = (0, 0, 0) BLUE = (0, 126, 231) # 007EE7 hex number def __init__(self): self.ai = AI() pygame.init() # initialize pygame self.red_selector = pygame.image.load("button-red.png") self.screen = pygame.display.set_mode((696, 700)) # screen size self.game_board = Board( self.screen) # initialize Game board with screen size self.settings = Settings() self.menu = Menu(self.screen) #self.turn = "red" self.player = 1 def play(self): self.game_board.reset_game() gameover = False # play until game is done while not gameover: if self.settings.gameActive is "pvp": for event in pygame.event.get(): # Events from player if event.type == pygame.QUIT: # Player chose to quit pygame.quit() quit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_w: #print("player decided to place here") if self.game_board.check_valid_move(): self.game_board.move() pygame.display.update() if self.game_board.check_win(): pygame.display.update() pygame.event.pump() time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) #blit win thing too? if self.game_board.move_count is 42: pygame.event.pump() #blit tie game time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) self.game_board.change_turn() elif event.key == pygame.K_a: # print("Player moved left!") self.game_board.move_select_button("left") pygame.display.update() elif event.key == pygame.K_s: print("Player knowns nothing") elif event.key == pygame.K_d: # print("Player moved right!") self.game_board.move_select_button("right") pygame.display.update() elif event.key == pygame.K_q: pygame.quit() quit() elif self.settings.gameActive is "pvai": if self.player: for event in pygame.event.get(): # Events from player if event.type == pygame.QUIT: # Player chose to quit pygame.quit() quit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_w: #print("player decided to place here") if self.game_board.check_valid_move(): self.game_board.move() pygame.display.update() pygame.event.pump() if self.game_board.check_win(): pygame.display.update() pygame.event.pump() time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) #blit win thing too? if self.game_board.move_count is 42: pygame.event.pump() #blit tie game time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) self.game_board.change_turn() self.player = 0 elif event.key == pygame.K_a: # print("Player moved left!") self.game_board.move_select_button("left") pygame.display.update() elif event.key == pygame.K_s: print("Player knowns nothing") elif event.key == pygame.K_d: # print("Player moved right!") self.game_board.move_select_button("right") pygame.display.update() elif event.key == pygame.K_q: pygame.quit() quit() else: print("ai") #ai moved = False score = 0 while not moved: move, score = self.ai.minimax(self.game_board, 1, -1000, 1000, True) print("Column Move: " + str(move)) # print("Minmax Number:" + str(move)) self.game_board.button_position = move while self.game_board.check_valid_move() is False: move += 1 self.game_board.button_position = move self.game_board.move() pygame.event.pump() pygame.display.update() moved = True if self.game_board.check_win(): pygame.display.update() pygame.event.pump() time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) # blit win thing too? if self.game_board.move_count is 42: pygame.event.pump() #blit tie game time.sleep(2) self.settings.toggle_game_active() pygame.mouse.set_visible(True) pygame.event.pump() self.game_board.reset_select_button() pygame.display.update() #x = 10000000 #while(x): #x = x-1 print("Score: " + str(score)) self.game_board.change_turn() self.player = 1 else: self.menu.draw_menu() pygame.display.update() for event in pygame.event.get(): # Events from player if event.type == pygame.QUIT: # Player chose to quit pygame.quit() quit() gameover = True elif event.type == pygame.MOUSEBUTTONDOWN: mouse_x, mouse_y = pygame.mouse.get_pos() self.menu.checkForPlayButtonClick( mouse_x, mouse_y, self.settings) if self.settings.gameActive: self.update_screen() # initialize window self.game_board.reset_game() self.game_board.load_board() # can be made in board def update_screen(self): self.screen.fill(game.BLUE) #self.game_board.blit() # call gameboard self.game_board.load_board() pygame.display.update() # update the entire screen = flip
from database import Database from menu import Menu from models.food import Food from models.types_of_food import Types_Of_Food Database.initialize() #t1 = Types_Of_Food.find_one_type(ttype="type5") #t2 = Types_Of_Food.find_one_type(ttype="type8") #print(t1) #print(t2) menu = Menu() menu.run_menu() """ food = Food(_id="4", name="name4", preparation="prep4", type_id="4") food.save_food() food2 = Food.find_one_food_by_name("name2") print(food2) """
# Added menu to select which gui to run # GUIs: madlib and restaurant # Restaurant currently does not calculate toal correctly from tkinter import * from menu import Menu if __name__ == '__main__': window = Tk() window.title("Simple GUIs") app = Menu(window) window.mainloop()
import os from menu import Menu from coffee_maker import CoffeeMaker from money_machine import MoneyMachine menu_object = Menu() coffee_maker_object = CoffeeMaker() money_machine_object = MoneyMachine() os.system("clear") not_turn_off = True while not_turn_off: # TODO: 1. Ask user option = input(f"What would you like? {menu_object.get_items()}: ") if option == "off": not_turn_off = False elif option == "report": coffee_maker_object.report() money_machine_object.report() else: drink = menu_object.find_drink(option) if coffee_maker_object.is_resource_sufficient(drink): if money_machine_object.make_payment(drink.cost): coffee_maker_object.make_coffee(drink) # Space between runs print("\n")
def select_student(students): selected_module = Menu.show_object(students, ['Select Student']) return selected_module
def select_module(modules): selected_module = Menu.show_object(modules, ['Select Module']) return selected_module
def main(): pg.init() pg.display.set_caption("Tetris") screen = pg.display.set_mode(solo_max_screen_coord) pg.key.set_repeat(delay, interval) normal_blocks_path = os.path.join('sprites', 'blocks.png') assist_blocks_path = os.path.join('sprites', 'assist_blocks.png') glow_blocks_path = os.path.join('sprites', 'glow_blocks.png') game_background_path = os.path.join('sprites', 'background.png') menu_background_path = os.path.join('sprites', 'background.png') grid_background_path = os.path.join('sprites', 'grid_background.png') # load backgrounds background_original = pg.image.load(game_background_path).convert() grid_background = pg.image.load(grid_background_path).convert() # load font font = pg.font.Font(os.path.join('fonts', font_file), 38) # load and scale all blocks (each tetromino has its own block color) def load_blocks(path, size, blocks_number): blocks_list = [] blocks = pg.image.load(path).convert_alpha() blocks = pg.transform.scale(blocks, (size * blocks_number, size)) for i in range(blocks_number): block_surface = blocks.subsurface(i * size, 0, size, size) blocks_list.append(block_surface) return blocks_list normal_blocks = load_blocks(normal_blocks_path, block_size, 8) assist_blocks = load_blocks(assist_blocks_path, block_size, 7) glow_blocks = load_blocks(glow_blocks_path, block_size + glow_size, 7) # (Left, Right, Rotate Clockwise, Rotate Counterclockwise, Drop, Speed Up) arrow_keys = (pg.K_LEFT, pg.K_RIGHT, pg.K_UP, pg.K_DOWN, pg.K_SPACE, pg.K_RSHIFT) letter_keys = (pg.K_a, pg.K_d, pg.K_w, pg.K_s, pg.K_LSHIFT, pg.K_z) # create menu menu_items = ['SINGLE PLAYER', 'MULTIPLAYER', 'CO-OP', 'QUIT'] main_menu = Menu('TETRIS', menu_background_path, screen_res, font_file, menu_coord) for item in menu_items: main_menu.add_item(item) # when game_over is True return to main menu while True: display_menu = True multiplayer = False coop = False while display_menu: screen = pg.display.set_mode(solo_max_screen_coord) background = pg.transform.scale(background_original, screen.get_size()) main_menu.show(screen) pg.display.flip() # wait for keyboard input event = pg.event.wait() user_input = main_menu.check_input(event) if user_input == menu_items[0]: # single player display_menu = False elif user_input == menu_items[1]: # multiplayer screen = pg.display.set_mode(multiplayer_max_screen_coord) background = pg.transform.scale(background_original, screen.get_size()) multiplayer = True display_menu = False elif user_input == menu_items[2]: # coop screen = pg.display.set_mode(coop_max_screen_coord) background = pg.transform.scale(background_original, screen.get_size()) display_menu = False coop = True elif user_input == menu_items[3] or event.type == pg.QUIT: # quit exit() player_list = [] if not coop: left_player = DefaultPlayer(grid_background, block_size, (0, 0), solo_max_screen_coord) player_list.append(left_player) else: path = os.path.join('sprites', 'coop_grid_background.png') temp = pg.image.load(path).convert() grid = Grid(20, 20, block_size, coop_max_screen_coord, temp) left_player = CoopPlayer(grid, block_size, (0, 0), 0) right_player = CoopPlayer(grid, block_size, (0, 0), 1) player_list.append(left_player) player_list.append(right_player) if multiplayer: right_player = DefaultPlayer( grid_background, block_size, (multiplayer_max_screen_coord[0] // 2, 0), multiplayer_max_screen_coord) player_list.append(right_player) game_over = game_paused = False clock = pg.time.Clock() total_time = 0.0 dt = 1.0 / FPS accumulator = 0.0 while not game_over: # keyboard input for event in pg.event.get(): if multiplayer or coop: left_player.check_input(event, letter_keys) right_player.check_input(event, arrow_keys) else: left_player.check_input(event, arrow_keys) if event.type == pg.QUIT: exit() elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE: game_over = True elif event.type == pg.KEYDOWN and event.key == pg.K_m: # mute sounds.mute = not sounds.mute if sounds.mute: pg.mixer.music.pause() else: pg.mixer.music.unpause() elif event.type == pg.KEYDOWN and event.key == pg.K_p: # Pause the game pause = True sounds.pause_sound.play() pg.mixer.music.pause() for player in player_list: player.display_message(screen, 'PAUSE') pg.display.flip() while pause: event = pg.event.wait() if event.type == pg.KEYDOWN and event.key == pg.K_p: pause = False elif event.type == pg.QUIT: exit() game_paused = True pg.mixer.music.unpause() sounds.pause_sound.play() if game_paused: frame_time = dt game_paused = False clock.tick(FPS) else: frame_time = clock.tick(FPS) / 1000.0 # convert to seconds # main game loop accumulator += frame_time while accumulator >= dt and not game_over: if multiplayer: left_player.insert_lines(right_player.get_lines_cleared()) right_player.insert_lines(left_player.get_lines_cleared()) elif coop: # all players must have the same difficulty level max_level = 0 for player in player_list: if player.get_difficulty_level() > max_level: max_level = player.get_difficulty_level() for player in player_list: if player.get_difficulty_level() != max_level: player.increase_difficulty_level() for player in player_list: player.main_loop(dt) game_over = game_over or player.is_game_over() accumulator -= dt # create strings if display_time: total_time += frame_time time_string = "TIME " + '{0:02d}'.format(int(total_time // 60))\ + ":" + '{0:02d}'.format(int(total_time % 60)) time_surface = write(font, time_string, text_color) if display_fps: fps_string = "FPS: " + str(int(clock.get_fps())) fps_surface = write(font, fps_string, text_color) # Draw screen.blit(background, min_screen_coord) if display_time: screen.blit(time_surface, time_coord) if display_fps: screen.blit(fps_surface, fps_coord) if coop: player_list[0].show_grid(screen, normal_blocks) for player in player_list: player.show(screen, normal_blocks, assist_blocks, glow_blocks) pg.display.flip() # end of game messages victory_color = (0, 255, 0) defeat_color = (255, 0, 0) tie_color = (255, 255, 0) tie = True # game over is True for all the players (tie) # game over is False for all the players (used escape to return to main menu) for player in player_list: tie = tie and player.is_game_over() game_over = game_over and not player.is_game_over() for player in player_list: if not multiplayer or (game_over and multiplayer): player.display_message(screen, 'GAME OVER', text_color) elif tie: player.display_message(screen, 'TIE', tie_color) elif player.is_game_over(): player.display_message(screen, 'DEFEAT', defeat_color) else: player.display_message(screen, 'VICTORY', victory_color) pg.display.flip() pg.mixer.music.stop() clock.tick(0.7)
class MainWindow(Gtk.Window): """ This class contains methods related the MainWindow class. """ # ---------------------------------------------------------------------- def __init__(self): """ This method is constructor. """ System() Gtk.Window.__init__(self, title="Mosaicode") self.resize(System.get_preferences().width, System.get_preferences().height) self.main_control = MainControl(self) # GUI components self.menu = Menu(self) self.toolbar = Toolbar(self) self.search = SearchBar(self) self.block_notebook = BlockNotebook(self) self.property_box = PropertyBox(self) self.work_area = WorkArea(self) self.status = Status(self) self.diagram_menu = DiagramMenu() self.menu.add_help() System.set_log(self.status) # vbox main # ----------------------------------------------------- # | Menu # ----------------------------------------------------- # | Toolbar # ----------------------------------------------------- # | V Paned bottom # ----------------------------------------------------- # First Vertical Box vbox_main = Gtk.VBox() self.add(vbox_main) vbox_main.pack_start(self.menu, False, True, 0) vbox_main.pack_start(self.toolbar, False, False, 0) self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL) vbox_main.add(self.vpaned_bottom) # vpaned_bottom # ----------------------------------------------------- # | hpaned_work_area # ===================================================== # | status # ----------------------------------------------------- self.hpaned_work_area = Gtk.HPaned() self.hpaned_work_area.connect("accept-position", self.__resize) self.hpaned_work_area.set_position( System.get_preferences().hpaned_work_area) self.vpaned_bottom.add1(self.hpaned_work_area) self.vpaned_bottom.add2(self.__create_frame(self.status)) self.vpaned_bottom.set_position(System.get_preferences().vpaned_bottom) self.vpaned_bottom.set_size_request(50, 50) # hpaned_work_area # ----------------------------------------------------- # | vbox_left || work_area # ----------------------------------------------------- vbox_left = Gtk.VBox(False, 0) self.hpaned_work_area.add1(vbox_left) self.hpaned_work_area.add2(self.work_area) # vbox_left # ----------------------------------------------------- # |search # ----------------------------------------------------- # |vpaned_left # ----------------------------------------------------- vbox_left.pack_start(self.search, False, False, 0) self.vpaned_left = Gtk.VPaned() vbox_left.pack_start(self.vpaned_left, True, True, 0) # vpaned_left # ----------------------------------------------------- # |blocks_tree_view # ===================================================== # |property_box # ----------------------------------------------------- self.vpaned_left.add1(self.__create_frame(self.block_notebook)) self.vpaned_left.add2(self.__create_frame(self.property_box)) self.vpaned_left.set_position(System.get_preferences().vpaned_left) self.connect("key-press-event", self.__on_key_press) self.connect("check-resize", self.__resize) self.main_control.init() # ---------------------------------------------------------------------- def __on_key_press(self, widget, event=None): if event.state == \ Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD2_MASK: if event.keyval == Gdk.KEY_a: self.main_control.select_all() return True return False # ---------------------------------------------------------------------- def __create_frame(self, widget): frame = Gtk.Frame() frame.set_shadow_type(Gtk.ShadowType.ETCHED_IN) frame.add(widget) frame.set_property("border-width", 4) return frame # ---------------------------------------------------------------------- def __resize(self, data): width, height = self.get_size() System.get_preferences().width = width System.get_preferences().height = height System.get_preferences( ).hpaned_work_area = self.hpaned_work_area.get_position() System.get_preferences( ).vpaned_bottom = self.vpaned_bottom.get_position() System.get_preferences().vpaned_left = self.vpaned_left.get_position() self.work_area.resize(data) # ---------------------------------------------------------------------- def update(self): self.main_control.update_all() # ---------------------------------------------------------------------- def set_title(self, title): """ This method set title. Parameters: * **title** (:class:`str<str>`) """ Gtk.Window.set_title(self, "Mosaicode (" + title + ")")
import pygame if __name__ == "__main__": from menu import Menu pygame.init() screen_w, screen_h = 1280, 960 screen = pygame.display.set_mode((screen_w, screen_h)) pygame.display.set_caption('Pong') game = Menu(screen) game.draw()
def __init__(self): """ This method is constructor. """ System() Gtk.Window.__init__(self, title="Mosaicode") self.resize(System.get_preferences().width, System.get_preferences().height) self.main_control = MainControl(self) # GUI components self.menu = Menu(self) self.toolbar = Toolbar(self) self.search = SearchBar(self) self.block_notebook = BlockNotebook(self) self.property_box = PropertyBox(self) self.work_area = WorkArea(self) self.status = Status(self) self.diagram_menu = DiagramMenu() self.menu.add_help() System.set_log(self.status) # vbox main # ----------------------------------------------------- # | Menu # ----------------------------------------------------- # | Toolbar # ----------------------------------------------------- # | V Paned bottom # ----------------------------------------------------- # First Vertical Box vbox_main = Gtk.VBox() self.add(vbox_main) vbox_main.pack_start(self.menu, False, True, 0) vbox_main.pack_start(self.toolbar, False, False, 0) self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL) vbox_main.add(self.vpaned_bottom) # vpaned_bottom # ----------------------------------------------------- # | hpaned_work_area # ===================================================== # | status # ----------------------------------------------------- self.hpaned_work_area = Gtk.HPaned() self.hpaned_work_area.connect("accept-position", self.__resize) self.hpaned_work_area.set_position( System.get_preferences().hpaned_work_area) self.vpaned_bottom.add1(self.hpaned_work_area) self.vpaned_bottom.add2(self.__create_frame(self.status)) self.vpaned_bottom.set_position(System.get_preferences().vpaned_bottom) self.vpaned_bottom.set_size_request(50, 50) # hpaned_work_area # ----------------------------------------------------- # | vbox_left || work_area # ----------------------------------------------------- vbox_left = Gtk.VBox(False, 0) self.hpaned_work_area.add1(vbox_left) self.hpaned_work_area.add2(self.work_area) # vbox_left # ----------------------------------------------------- # |search # ----------------------------------------------------- # |vpaned_left # ----------------------------------------------------- vbox_left.pack_start(self.search, False, False, 0) self.vpaned_left = Gtk.VPaned() vbox_left.pack_start(self.vpaned_left, True, True, 0) # vpaned_left # ----------------------------------------------------- # |blocks_tree_view # ===================================================== # |property_box # ----------------------------------------------------- self.vpaned_left.add1(self.__create_frame(self.block_notebook)) self.vpaned_left.add2(self.__create_frame(self.property_box)) self.vpaned_left.set_position(System.get_preferences().vpaned_left) self.connect("key-press-event", self.__on_key_press) self.connect("check-resize", self.__resize) self.main_control.init()
def create_menu(): menu = Menu() menu.add_option('1', 'Add Book', add_book) menu.add_option('2', 'Search For Book', search_book) menu.add_option('3', 'Show Unread Books', show_unread_books) menu.add_option('4', 'Show Read Books', show_read_books) menu.add_option('5', 'Show All Books', show_all_books) menu.add_option('6', 'Change Book Read Status', change_read) menu.add_option('7', 'Delete Book', delete_book) menu.add_option('Q', 'Quit', quit_program) return menu
from highscore import Pontuacao from dificuldades import Dificuldade janela = Window(globais.WIDTH,globais.HEIGHT) tela = Tela(janela) tela.setFundo() teclado = Keyboard() dificuldade = Dificuldade() dificuldade.setDificuldade() humano = Humano(janela) menu = Menu(janela) posicoes = Posicoes(janela) pontuacao = Pontuacao(janela) while True: tela.setTela() if(teclado.key_pressed("RIGHT")): globais.STATUS_PERSONAGEM = 2 posicoes.setUpdate() while(globais.STATUS_PERSONAGEM == 2): if globais.GAME_STATE == 1: tela.getFundo() posicoes.getUpdate()
board = Board() pins = [board.getPin(18)] def just_print(x): print("Just print") print(x) q.put(game) def game(): t = 0 while t < 2000: time.sleep(0.01) t += 1 print("Game over") def re_assign(pins): print("Reassign") for pin in pins: pin.registerHandler(just_print) menu = Menu(ledArray, pins, [MenuItem("Test", lambda x: re_assign(pins))]) menu.show(0) while True: game = q.get() game() time.sleep(0.01)
## @file main.py # Main file for project # # Project: Minesweeper # Author: All # Created: 09/06/18 from menu import Menu playing = Menu() playing.game_rules() playing.game_menu()
class Magic: #Cast not a method so it's compatible with Menu - it needed to be of the form func(string), so string.method() def __init__(self, name, manacost, damage=None ): #was proving difficult to make work with the menu class self.name = name self.manacost = manacost spells.append(self) self.damage = damage if damage == None: string = "Costs " + str(manacost) + " mana." else: string = "Costs " + str(manacost) + " mana to do " + str( damage) + " damage." self.desc = string a = Magic("Sparks", 0, 4) a = Magic("Confringo", 1, 8) magicMenu = Menu( ) #addMenuOption(displayname,commandname,outputfunc,helpdescription,expectedinput,abbreviation=None) magicMenu.addMenuOption("cast", "cast", cast, "casts a spell -- see spell list for options", "spell", "c") magicMenu.addMenuOption("spell list", "spell", spelllist, "lists currently known spells", None, "sl") magicMenu.addMenuOption("run", "run", run, "escapes into an adjacent room", None, "r")
def __init__(self, items): self.__name = "WebSelect" self.__second_menu = Menu(items)
from menu import Menu from .sites import site for item in site.get_menu(): Menu.add_item('cbvadmin', item)
import sys from PyQt5 import QtWidgets from menu import Menu if __name__ == '__main__': app = QtWidgets.QApplication(sys.argv) screen = app.primaryScreen() rect = screen.availableGeometry() menu = Menu(rect.width(), rect.height()) sys.exit(app.exec_())
def main(): # wydarzenia przechowuj w liście calendar = [] # zakładamy, że wydarzenie to słownik z kluczami title, date, time # jeśli chcesz przechowywać wydarzenie w innej strukturze danych # to pamiętaj o zmianie jej obsługi w funkcji list_calendar event = { 'title': 'Programowanie obiektowe w jezyku PYTHON - Cwiczenia', 'date': '28.03.2020', 'time': '12:45', } calendar.append(event) menu = Menu() # tutaj możesz dodać kolejne polecenia do menu # menu.add_command(MenuCommand(menu) menu.add_command(StartCommand(menu)) menu.add_command(OptionCommand(menu)) menu.add_command(AddCommand(menu)) menu.add_command(ExitCommand(menu)) menu.run()
from menu import Menu, MenuItem from coffee_maker import CoffeeMaker from money_machine import MoneyMachine My_Menu = Menu() MakeCoffee = CoffeeMaker() Money = MoneyMachine() Machine_working = True while Machine_working: choice = input("What do you want? espresso, latte, cappuccino: ").lower() if choice == 'off': Machine_working = False elif choice == 'report': MakeCoffee.report() Money.report() else: drink = My_Menu.find_drink(choice) if MakeCoffee.is_resource_sufficient(drink) and Money.make_payment( drink.cost): MakeCoffee.make_coffee(drink)
file_root = None python_root = None data_dir = None actions_dir = None store_file = None user_db = None status_log_file = None access_log_file = None pidfile = None host = None port = None debug = False no_daemon = False server_dir = '/' main_menu = Menu() def read(): """Read configuration""" directory = os.path.dirname(os.path.realpath(__file__)) parser = SafeConfigParser(defaults={ 'root': directory, }) parser.read(os.path.join(directory, 'plinth.config')) config_items = {('Name', 'product_name'), ('Name', 'box_name'), ('Path', 'root'), ('Path', 'file_root'), ('Path', 'python_root'), ('Path', 'data_dir'), ('Path', 'store_file'), ('Path', 'user_db'), ('Path', 'actions_dir'), ('Path', 'status_log_file'),
from menu import Menu, MenuItem from coffee_maker import CoffeeMaker from money_machine import MoneyMachine # Create objects machine_menu = Menu() resources_management = CoffeeMaker() cash_machine = MoneyMachine() while True: menu_choice = input( f" What would you like? ({machine_menu.get_items()}): ") if menu_choice == "off": break elif menu_choice == "report": resources_management.report() cash_machine.report() else: drink_chosen = machine_menu.find_drink(menu_choice) if not drink_chosen: continue enough_resources = resources_management.is_resource_sufficient( drink_chosen) if not enough_resources: continue
main_menu.display() def open_feed(): webbrowser.open(feed_address) # Main menu main_menu_run = Button("Run", parse_feeds, 1) main_menu_edit = Button("Edit Filters", filters_to_textfile, 2) main_menu_all = Button("List All Filters And Conditions", list_all, 3) main_menu_downloaded = Button("List All Downloaded Entries", list_downloaded, 4) main_menu_feed = Button("Open Feed", open_feed, 5) main_menu_exit = Button("Exit", sys.exit, 0) main_menu_buttons = [ main_menu_run, main_menu_edit, main_menu_all, main_menu_downloaded, main_menu_feed, main_menu_exit ] main_menu = Menu("Main Menu", main_menu_buttons) try: if sys.argv[1] == "-run": parse_feeds() except IndexError: pass main_menu.display()
from menu import Menu from coffee_maker import CoffeeMaker from money_machine import MoneyMachine money_machine = MoneyMachine() coffee_maker = CoffeeMaker() menu = Menu() is_on = True while is_on: options = menu.get_items() choice = input(f"what would you like? {options}:\t") if choice == "off": is_on = False elif choice == "report": coffee_maker.report() money_machine.report() else: drink = menu.find_drink(choice) if coffee_maker.is_resource_sufficient( drink) and money_machine.make_payment(drink.cost): coffee_maker.make_coffee(drink)
def buildMenu(self, drink_list, drink_options): # create a new main menu m = Menu("Main Menu") # add drink options drink_opts = [] for d in drink_list: drink_opts.append( MenuItem('drink', d["name"], {"ingredients": d["ingredients"]})) configuration_menu = Menu("Configure") # add pump configuration options pump_opts = [] for p in sorted(self.pump_configuration.keys()): config = Menu(self.pump_configuration[p]["name"]) # add fluid options for each pump for opt in drink_options: # star the selected option selected = "*" if opt["value"] == self.pump_configuration[p][ "value"] else "" config.addOption( MenuItem('pump_selection', opt["name"], { "key": p, "value": opt["value"], "name": opt["name"] })) # add a back button so the user can return without modifying config.addOption(Back("Back")) config.setParent(configuration_menu) pump_opts.append(config) # add pump menus to the configuration menu configuration_menu.addOptions(pump_opts) # add a back button to the configuration menu configuration_menu.addOption(Back("Back")) # adds an option that cleans all pumps to the configuration menu configuration_menu.addOption(MenuItem('clean', 'Clean')) configuration_menu.setParent(m) m.addOptions(drink_opts) m.addOption(configuration_menu) # create a menu context self.menuContext = MenuContext(m, self)