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

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 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 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 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 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 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 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 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 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 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 __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 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])