Пример #1
0
 def handle_home_select(self):
     display = self.view.menu_stack[-1]
     index = display.index + display.start_index
     if index == HomeOptions.EXIT:
         return False
     elif index == HomeOptions.PLAYLISTS:
         path = cfg.home_menu_items[HomeOptions.PLAYLISTS]
         items = self.library.get_disk_items(cfg.playlist_dir)
         display = Display(items, path)
         self.view.menu_stack.append(display)
     elif index == HomeOptions.TRACKS:
         path = cfg.home_menu_items[HomeOptions.TRACKS]
         display = Display(self.library.get_tracks(), path)
         self.view.menu_stack.append(display)
     elif index == HomeOptions.ALBUMS:
         self.handle_album_select()
     elif index == HomeOptions.ARTISTS:
         self.handle_artist_select()
     elif index == HomeOptions.GENRES:
         self.handle_genre_select()
     elif index == HomeOptions.QUEUE:
         self.handle_queue_select()
     elif index == HomeOptions.SETTINGS:
         self.view.notify(cfg.not_implemented_str)
     return True
Пример #2
0
 def __init__(self):
     self.my_view = Display()
     self.game_map = Map()
     self.my_view.draw_map(self.game_map.game_map_source)
     self.chars_on_screen = []
     self.enemies_on_screen = []
     self.create_hero(0, 0)
     self.create_enemy()
     self.my_view.root.bind("<KeyPress>", self.on_key_press)
     self.my_view.root.bind("<space>", self.on_space_press)
     self.my_view.starter()
Пример #3
0
 def handle_queue_select(self):
     display_path = cfg.home_menu_items[HomeOptions.QUEUE]
     display_items = []
     for item in self.player.next_tracks:
         display_items.append(DisplayItem(ItemType.Track, item))
     new_display = Display(display_items, display_path)
     self.view.menu_stack.append(new_display)
Пример #4
0
 def handle_genre_select(self):
     path = cfg.home_menu_items[HomeOptions.GENRES]
     display_items = []
     for key in self.library.genres:
         display_items.append(DisplayItem(ItemType.Directory, key))
     display = Display(display_items, path)
     self.view.menu_stack.append(display)
Пример #5
0
 def handle_artist_select(self):
     path = cfg.home_menu_items[HomeOptions.ARTISTS]
     display_items = []
     for key in self.library.artists.keys():
         display_items.append(DisplayItem(ItemType.Directory, key))
     display = Display(display_items, path)
     self.view.menu_stack.append(display)
Пример #6
0
class Game:
	""""""
	def __init__(self):
		self.a_model = ModelStuff()
		self.the_display = Display()

##############################################################################
#	Please excuse the use of temporary print statements to simulate program
#	flow because it violates the MVC. Eventually all view elements will
#	be assemballed into a single string to be displayed all at once (see 
#	display).
#
#############################################################################  
	
	def start_round(self):
		"""Runs a round"""
		self.a_model.juggle_the_masters_ballz()
		
		print(self.the_display.draw_welcome())

		print("The master's Guess: ", self.the_display.draw_masters_ballz(self.a_model.masters_ballz))
		

		 
		# create a new guess object by using the input from the display.
		# calling a method from display object
		styrofoam_cup = self.the_display.get_user_guess()
		styrofoam_cup = self.the_display.validate_guess_format_template(styrofoam_cup)

		print("Turn number:", self.a_model.turn)
		x = Guess(styrofoam_cup)

		"""the above code acomplishes passing a valid formated list on balls 
		into a guess object """

		#Prints prove that we succesfully transfered the users input into model.
		print(x.this_guess)

		print(self.the_display.draw_win())

		print(self.the_display.draw_loser())





		"""decide to loop back for valid input
		 string based on validate_guess_format_template(all_guess[ : ], turn): loop back to start_round():"""
		""" Decide to loop back for valid input based on 
Пример #7
0
    def handle_lib_subset(self):
        curr_display = self.view.menu_stack[-1]
        menu_path = curr_display.menu_path
        key = curr_display.get_selected_item().path
        if cfg.home_menu_items[HomeOptions.ALBUMS] in menu_path:
            key_items = self.library.albums.get(key)
        elif cfg.home_menu_items[HomeOptions.ARTISTS] in menu_path:
            key_items = self.library.artists.get(key)
        elif cfg.home_menu_items[HomeOptions.GENRES] in menu_path:
            key_items = self.library.genres.get(key)

        if not key_items:
            self.view.notify(cfg.load_error_str)
            return
        else:
            new_item_list = []
            for item in key_items:
                new_item_list.append(DisplayItem(ItemType.Track, item))
            new_path = os.path.join(curr_display.menu_path, key)
            new_display = Display(new_item_list, new_path)
        self.view.menu_stack.append(new_display)
Пример #8
0
    def cli(self):
        Display.greeting()
        continu = True

        while continu:
            substitutes = self.database.get_substitute()
            self.control.substitution(substitutes)
            records_cat = self.database.get_infos_category()
            Display.display_categories(records_cat)
            choice = self.control.check_input(
                "\nChoose the index of one of the categories:",
                records_cat,
            )
            records_prod = self.database.get_infos_product(choice)
            records_prod_cleaned = ProductsCleaned().clean(records_prod)
            sampling = Display.display_category_product(
                choice, records_cat, records_prod_cleaned)
            choice_prod = self.control.check_input(
                "\nChoose the index of one of the products:",
                sampling,
            )
            records_prod = Display.display_products(choice_prod,
                                                    records_prod_cleaned)
            choice_subs = self.control.check_input(
                "\nChoose the index of a product to substitute: ",
                records_prod,
            )
            selec = [(1, 1), (2, 2)]
            choice = self.control.check_input(
                "\nDo you want to register this substitute "
                "in the database?\n\n1:no\n2:yes\n\nYour answer: ",
                selec,
            )
            if choice == 2:
                self.database.update_data(choice_prod, choice_subs)
            else:
                pass
            choice = self.control.check_input(
                "\nDo you want to search other products?"
                "\n\n1:no\n2:yes\n\nYour answer: ",
                selec,
            )
            if choice == 1:
                self.database.cursor.close()
                break
Пример #9
0
    def handle_playlist_select(self, item, ext, display):
        tracks = self.library.get_playlist_tracks(display.menu_path)
        playlist = os.path.basename(display.menu_path)
        items = []
        for track in tracks:
            items.append(DisplayItem(ItemType.Track, track))

        if item.path == cfg.media_option_items[MediaOptions.VIEW]:
            new_display = Display(items, display.menu_path)
            self.view.menu_stack.append(new_display)
        elif item.path == cfg.media_option_items[MediaOptions.PLAY]:
            if not self.player.play(display.menu_path):
                self.view.notify(cfg.play_error_str)
            else:
                self.view.notify(cfg.playing_str)
            self.view.menu_stack.pop()
        elif item.path == cfg.media_option_items[MediaOptions.QUEUE_NEXT]:
            self.player.queue_next(tracks)
            self.view.menu_stack.pop()
            self.view.notify(playlist + cfg.play_next_str)
        elif item.path == cfg.media_option_items[MediaOptions.QUEUE_LAST]:
            self.player.queue_last(tracks)
            self.view.menu_stack.pop()
            self.view.notify(playlist + cfg.play_last_str)
Пример #10
0
 def handle_dir_select(self, item_path: str, display):
     item_name = item_path.split(os.sep)[-1]
     display_path = display.menu_path + os.sep + item_name
     item_list = self.library.get_disk_items(item_path)
     new_display = Display(item_list, display_path)
     self.view.menu_stack.append(new_display)
Пример #11
0
 def handle_media_select(self, item_path: str, display: Display):
     items = []
     for opt in cfg.media_option_items:
         items.append(DisplayItem(ItemType.Menu, opt))
     new_display = Display(items, item_path)
     self.view.menu_stack.append(new_display)
Пример #12
0
class Game:
    def __init__(self):
        self.my_view = Display()
        self.game_map = Map()
        self.my_view.draw_map(self.game_map.game_map_source)
        self.chars_on_screen = []
        self.enemies_on_screen = []
        self.create_hero(0, 0)
        self.create_enemy()
        self.my_view.root.bind("<KeyPress>", self.on_key_press)
        self.my_view.root.bind("<space>", self.on_space_press)
        self.my_view.starter()

    def create_hero(self, x, y):
        self.hero = self.my_view.draw_entity(self.my_view.char_down, [x, y])
        self.heroEntity = Hero()
        self.heroEntity.id = self.hero
        self.chars_on_screen.append(self.hero)

        self.my_view.hero_hud(self.heroEntity)

    def create_enemy(self):
        self.skeleton1 = self.my_view.draw_entity(self.my_view.skeleton,
                                                  self.random_spawn())
        self.chars_on_screen.append(self.skeleton1)
        self.skeleton2 = self.my_view.draw_entity(self.my_view.skeleton,
                                                  self.random_spawn())
        self.chars_on_screen.append(self.skeleton2)
        self.skeleton3 = self.my_view.draw_entity(self.my_view.skeleton,
                                                  self.random_spawn())
        self.chars_on_screen.append(self.skeleton3)
        self.boss = self.my_view.draw_entity(self.my_view.boss,
                                             self.random_spawn())
        self.chars_on_screen.append(self.boss)

        obj = Boss()
        obj.id = self.boss
        self.enemies_on_screen.append(obj)
        self.bossEntity = obj

        obj = Skeleton()
        obj.id = self.skeleton1
        self.enemies_on_screen.append(obj)

        obj = Skeleton()
        obj.id = self.skeleton2
        self.enemies_on_screen.append(obj)

        obj = Skeleton()
        obj.id = self.skeleton3
        self.enemies_on_screen.append(obj)

        print(self.chars_on_screen)
        print(self.skeleton1)

    def random_spawn(self):
        coords = [0, 0]
        while self.is_occupied(coords[0],
                               coords[1]) or self.game_map.get_wall_coords(
                                   coords[0] * 72, coords[1] * 72) == 1:
            coords[0] = randint(0, 9)
            coords[1] = randint(0, 8)
        return coords

    def is_occupied(self, x, y):
        for image in self.chars_on_screen:

            coords = self.my_view.canvas.coords(image)
            its_occupied = coords[0] == x and coords[1] == y
            if its_occupied:
                break
        return its_occupied

    def get_entity_on_pos(self, x, y):
        for image in self.enemies_on_screen:

            coords = self.my_view.canvas.coords(image.id)
            its_occupied = coords[0] == x and coords[1] == y
            if its_occupied:
                return image
        return 0

    def meet_with_someone(self, x, y):
        entity = self.get_entity_on_pos(x, y)
        if entity == 0:
            return entity

        if (entity == self.bossEntity):
            self.my_view.boss_hud(self.bossEntity)
        else:
            self.my_view.skeleton_hud(entity)

        return entity

    def move(self, dx, dy):
        self.my_view.canvas.move(self.hero, dx * 72, dy * 72)

    def on_key_press(self, e):
        coords = self.my_view.canvas.coords(self.hero)
        if (e.keysym == 'Up'):
            self.my_view.canvas.itemconfigure(self.hero,
                                              image=self.my_view.char_up)
            if coords[1] > 0 and not self.game_map.get_wall_coords(
                    coords[0], coords[1] - 72) == 1:
                self.meet_with_someone(coords[0], coords[1] - 72)
                self.move(0, -1)
        elif (e.keysym == 'Down'):
            self.my_view.canvas.itemconfigure(self.hero,
                                              image=self.my_view.char_down)
            if coords[1] < 648 and not self.game_map.get_wall_coords(
                    coords[0], coords[1] + 72) == 1:
                self.meet_with_someone(coords[0], coords[1] + 72)
                self.move(0, 1)
        elif (e.keysym == 'Right'):
            self.my_view.canvas.itemconfigure(self.hero,
                                              image=self.my_view.char_right)
            if coords[0] < 648 and not self.game_map.get_wall_coords(
                    coords[0] + 72, coords[1]) == 1:
                self.meet_with_someone(coords[0] + 72, coords[1])
                self.move(1, 0)
        elif (e.keysym == 'Left'):
            self.my_view.canvas.itemconfigure(self.hero,
                                              image=self.my_view.char_left)
            if coords[0] > 0 and not self.game_map.get_wall_coords(
                    coords[0] - 72, coords[1]) == 1:
                self.meet_with_someone(coords[0] - 72, coords[1])
                self.move(-1, 0)

    def on_space_press(self, e):
        coords = self.my_view.canvas.coords(self.hero)
        entity = self.meet_with_someone(coords[0], coords[1])
        self.fight(entity)
        self.my_view.hero_hud(self.heroEntity)

    def fight(self, entity):
        self.heroEntity.strike_entity(entity)
        entity.strike_entity(self.heroEntity)
Пример #13
0
def test_display_products():
    database = Db()
    display = Display()
    rec_prod = [
        (
            31,
            "Ice Tea saveur Pêche",
            "d",
            82,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            32,
            "Ice Tea pêche",
            "d",
            82,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            33,
            "Thé glacé pêche intense",
            "d",
            79,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            34,
            "Thé infusé glacé, Thé noir parfum pêche blanche",
            "d",
            84,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            35,
            "Thé vert infusé glacé saveur Menthe",
            "d",
            84,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            36,
            "Thé noir évasion pêche & saveur hibiscus",
            "d",
            79,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            37,
            "Thé glacé pêche intense",
            "d",
            79,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            38,
            "FROSTIES",
            "d",
            1569,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            39,
            "Sucre glace",
            "d",
            1674,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
        (
            40,
            "fuze tea pêche intense (thé glacé)",
            "d",
            79,
            "Auchan",
            "https://fr-en.openfoodfacts.org/product/7622210601988/yahourt",
        ),
    ]
    prod_displayed = display.display_products(38, rec_prod)
    for prod in prod_displayed:
        assert prod[0] != 38
Пример #14
0
	def __init__(self):
		self.a_model = ModelStuff()
		self.the_display = Display()