예제 #1
0
    def ask(self):
        self.prompt_user()
        UI.display('Loading ..')
        self.add_more_questions()

        ques = None
        score = 0

        while self.question_count > 0:
            ques = self.manager.get_question(self.current_question)
            self.current_question += 1

            UI.display(ques.question)
            answer = UI.get_input('Answer: ')

            try:
                if ques.answer == int(answer):
                    UI.display('Correct!\n')
                    score += 2
                else:
                    UI.display('Wrong!\n')
                    break

            except ValueError:
                UI.display('Please enter a valid answer.')
                self.current_question -= 1
                continue

            if self.question_count == 1:
                self.add_more_questions()

            self.question_count -= 1

        self.manager.set_score(self.user, score)
예제 #2
0
    def ask(self):
        self.prompt_user()
        UI.display('Loading ..')
        self.add_more_questions()

        ques = None
        score = 0

        while self.question_count > 0:
            ques = self.manager.get_question(self.current_question)
            self.current_question += 1

            UI.display(ques.question)
            answer = UI.get_input('Answer: ')

            try:
                if ques.answer == int(answer):
                    UI.display('Correct!\n')
                    score += 2
                else:
                    UI.display('Wrong!\n')
                    break

            except ValueError:
                UI.display('Please enter a valid answer.')
                self.current_question -= 1
                continue

            if self.question_count == 1:
                self.add_more_questions()

            self.question_count -= 1

        self.manager.set_score(self.user, score)
예제 #3
0
 def start(self):
     while True:
         command = UI.get_input("> ")
         if command == 'start':
             self.ask()
         elif command == 'highscores':
             UI.display(self.show_highscores())
         elif command == 'help':
             UI.display(self.__HELP_MESSAGE)
         elif command == 'exit':
             return
예제 #4
0
 def start(self):
     while True:
         command = UI.get_input("> ")
         if command == 'start':
             self.ask()
         elif command == 'highscores':
             UI.display(self.show_highscores())
         elif command == 'help':
             UI.display(self.__HELP_MESSAGE)
         elif command == 'exit':
             return
예제 #5
0
class Level:
    def __init__(self):

        # get the display surface
        self.display_surface = pygame.display.get_surface()
        self.game_paused = False
        self.open_game_over = False
        self.open_game_wins = False
        self.inimigos = []

        # sprite group setup
        self.visible_sprites = YSortCameraGroup()
        self.obstacle_sprites = pygame.sprite.Group()

        # attack sprites
        self.current_attack = None
        self.attack_sprites = pygame.sprite.Group()
        self.attackable_sprites = pygame.sprite.Group()

        # sprite setup
        self.create_map()

        # user interface
        self.ui = UI()
        self.upgrade = Upgrade(self.player)

        # particles
        self.animation_player = AnimationPlayer()
        self.magic_player = MagicPlayer(self.animation_player)

    def setOpenGameWins(self):
        self.open_game_wins = True

    def create_map(self):
        layouts = {
            'boundary': import_csv_layout('../map/mapateste_barreira.csv'),
            'entities': import_csv_layout('../map/mapateste_inimigos.csv')
        }

        for style, layout in layouts.items():
            for row_index, row in enumerate(layout):
                for col_index, col in enumerate(row):
                    if col != '-1':
                        x = col_index * TILESIZE
                        y = row_index * TILESIZE
                        if style == 'boundary':
                            Tile((x, y), [self.obstacle_sprites], 'invisible')

                        if style == 'entities':
                            if col == '394':
                                self.player = Player(
                                    (x, y), [self.visible_sprites],
                                    self.obstacle_sprites, self.create_attack,
                                    self.destroy_attack, self.create_magic)
                            else:
                                if col == '390':
                                    monster_name = 'duende'
                                elif col == '389':
                                    monster_name = 'boss'
                                else:
                                    monster_name = 'esqueleto'
                                self.inimigo = Enemy(
                                    monster_name, (x, y), [
                                        self.visible_sprites,
                                        self.attackable_sprites
                                    ], self.obstacle_sprites,
                                    self.damage_player,
                                    self.trigger_death_particles, self.add_exp,
                                    self.setOpenGameWins)
                                self.inimigos.append(self.inimigo)

    def kill_all_enemies(self):
        for inimigo in self.inimigos:
            inimigo.kill()

    def create_attack(self):
        self.current_attack = Weapon(
            self.player, [self.visible_sprites, self.attack_sprites])

    def create_magic(self, style, strength, cost):
        if style == 'heal':
            self.magic_player.heal(self.player, strength, cost,
                                   [self.visible_sprites])

        if style == 'flame':
            self.magic_player.flame(
                self.player, cost, [self.visible_sprites, self.attack_sprites])

    def destroy_attack(self):
        if self.current_attack:
            self.current_attack.kill()
        self.current_attack = None

    def player_attack_logic(self):
        if self.attack_sprites:
            for attack_sprite in self.attack_sprites:
                collision_sprites = pygame.sprite.spritecollide(
                    attack_sprite, self.attackable_sprites, False)
                if collision_sprites:
                    for target_sprite in collision_sprites:
                        if target_sprite.sprite_type == 'grass':
                            pos = target_sprite.rect.center
                            offset = pygame.math.Vector2(0, 75)
                            for leaf in range(randint(3, 6)):
                                self.animation_player.create_grass_particles(
                                    pos - offset, [self.visible_sprites])
                            target_sprite.kill()
                        else:
                            target_sprite.get_damage(self.player,
                                                     attack_sprite.sprite_type)

    def damage_player(self, amount, attack_type):
        if self.player.vulnerable:
            self.player.health -= amount
            self.player.vulnerable = False
            self.player.hurt_time = pygame.time.get_ticks()
            if self.player.health <= 0:
                self.open_game_over = True
                self.kill_all_enemies()

            #self.animation_player.create_particles(attack_type,self.player.rect.center,[self.visible_sprites])

    def trigger_death_particles(self, pos, particle_type):
        pass

    #    self.animation_player.create_particles(particle_type,pos,self.visible_sprites)

    def add_exp(self, amount):
        self.player.exp += amount

    def toggle_menu(self):
        self.game_paused = not self.game_paused

    def run(self):
        self.visible_sprites.custom_draw(self.player)
        self.ui.display(self.player)

        if self.game_paused:
            self.upgrade.display()
        else:
            self.visible_sprites.update()
            self.visible_sprites.enemy_update(self.player)
            self.player_attack_logic()

        if self.open_game_over:
            return 2
        elif self.open_game_wins:
            return 1
        else:
            return 0
예제 #6
0
class Game:
    def __init__(self, db):
        if (db == "mongo"):
            self.dbserver = MongoDb()

#        self.dbserver.load_questions()
        self.ui = UI()

        self.categories = pd.DataFrame.from_records(
            pd.read_json(
                "https://opentdb.com/api_category.php").trivia_categories)
        self.categories.set_index("id", inplace=True)

        self.start_game("normal")

    def update_db(self, batch):
        for i in range(len(batch)):
            self.dbserver.update_db(batch.iloc[i].name,
                                    batch.iloc[i].user_name,
                                    batch.iloc[i].correct_answer)

    def user_mode(self):

        self.user_name = self.ui.input("Please enter your name: ")
        self.display_categories("Choose a category of questions: \n")
        #        self.ui.display("\n".join(self.categories["name"]))
        self.user_category = str.title(self.ui.input("\n"))
        self.user_difficulty = str.lower(
            self.ui.input("Choose difficulty level (easy, medium, hard): "))
        self.user_number_of_questions = self.ui.input(
            "Please enter number of questions: ")

        self.session = pd.DataFrame(
            self.dbserver.get_question(self.user_category,
                                       self.user_difficulty,
                                       self.user_number_of_questions))
        batch = {}

        while len(self.session):
            question = self.session.iloc[len(self.session) - 1]
            self.session = self.session.drop(len(self.session) - 1)
            self.ui.displayHTMLchars(question["question"])
            answers = question["incorrect_answers"]
            correct_answer = html.unescape(question["correct_answer"])
            answers.append(correct_answer)
            while len(answers):
                self.ui.displayHTMLchars(answers.pop())
            answer = self.ui.input("\nPlease enter your answer: ")
            is_correct_answer = (answer == correct_answer)
            if is_correct_answer:
                self.ui.display("Correct!")
            else:
                self.ui.display("Wrong")

            batch[question["_id"]] = (self.user_name, is_correct_answer)

        batch = pd.DataFrame.from_dict(batch,
                                       orient="index",
                                       columns=["user_name", "correct_answer"])
        self.ui.display(
            f"You answered correctly to {batch.correct_answer.sum()} out of {batch.correct_answer.count()} questions!"
        )
        self.update_db(batch)

    def display_categories(self, intro_text):
        self.ui.display(intro_text)
        self.ui.display("\n".join(self.categories["name"]))

    def add_category(self):
        self.display_categories("Current categories: ")
        category = self.ui.input("\nEnter your new category: ")
        self.categories.loc[self.categories.index.max() + 1, "name"] = category


# TODO : categories should be stored in the database

    def remove_category(self):
        self.display_categories("Current categories: ")
        category = self.ui.input("\nEnter category id to be removed: ")
        self.categories.drop(index=category, inplace=True)

    def add_question(self):
        self.display_categories("Choose a category: ")
        category = str.title(self.ui.input("\n"))
        qtype = None
        while (qtype != "boolean" or qtype != "multiple"):
            qtype = self.ui.input(
                "What is the type of the question? boolean or multiple choice [boolean/multiple] "
            )
        difficulty = None
        while (difficulty not in ["easy", "medium", "hard"]):
            difficulty = str.lower(
                self.ui.input(
                    "Choose difficulty level (easy, medium, hard): "))
        question = self.ui.input("Enter your question:\n")
        if (qtype == "boolean"):
            correct_answer = None
            while (correct_answer != "True" or correct_answer != "False"):
                correct_answer = str.capitalize(
                    self.ui.input("Enter correct answer (True/False): "))
            if (correct_answer) == "True":
                incorrect_answer = ["False"]
            else:
                incorrect_answer = ["True"]
        else:
            correct_answer = self.ui.input("Enter correct answer:\n")
            incorrect_answer = []
            for i in range(3):
                incorrect_answer.append(
                    self.ui.input(f"Enter incorrect answer number {i+1}:\n"))

        new_question = {
            "category": category,
            "type": qtype,
            "difficulty": difficulty,
            "question": question,
            "correct_answer": correct_answer,
            "incorrect_answers": incorrect_answer
        }
        self.dbserver.add_question(new_question)

    def load_questions(self):
        amount = self.ui.input(
            "How many questions would you like to load from online database? ")
        self.dbserver.load_questions(amount)

    def admin_menu(self):
        self.ui.display("1. Add a category")
        self.ui.display("2. Remove a category")
        self.ui.display("3. Add a question")
        self.ui.display("4. Load questions from database")
        self.ui.display("5. Get game statistics")
        return self.ui.input("Enter your choice [1-5]: ")

    def admin_statistics(self):
        self.ui.display("1. Correct answers by category")
        self.ui.display("2. Correct answers by difficulty level")
        self.ui.display("3. Users' statistics")
        choice = 4
        while not (choice >= 1 and choice <= 3):
            choice = int(self.ui.input("Please enter your choice [1-3]: "))

    def admin_mode(self):
        menu = self.admin_menu()
        if (menu == 1):
            self.add_category()
        elif (menu == 2):
            self.remove_category()
        elif (menu == 3):
            self.add_question()
        elif (menu == 4):
            self.load_questions()
        elif (menu == 5):
            self.admin_statistics()

    def start_game(self, mode="normal"):
        if (mode == "normal"):
            self.user_mode()
        if (mode == "admin"):
            self.admin_mode()
예제 #7
0
class Game:
    welcome_message = '\n{} {} {}\nWrite start to play or exit to quit!'.format(
                      '-' * 10, 'Tic Tac Toe!', '-' * 10)

    winner_message = 'Game Over! Winner is {}'

    winning_routes = [[(0, 0), (0, 1), (0, 2)],
                      [(0, 0), (1, 0), (2, 0)],
                      [(0, 0), (1, 1), (2, 2)],
                      [(1, 0), (1, 1), (1, 2)],
                      [(0, 1), (1, 1), (2, 1)],
                      [(0, 2), (1, 2), (2, 2)],
                      [(2, 0), (2, 1), (2, 2)],
                      [(2, 0), (1, 1), (0, 2)]]

    def __init__(self):
        self.UI = UI()

        self.AI = AI(self.UI.BOARD, self.winning_routes)
        self.player = None
        self.game_over = False

    def input_choice(self):
        x = int(self.UI.get_input('x: '))
        y = int(self.UI.get_input('y: '))

        if self.are_x_y_valid(x, y) or self.UI.BOARD[x][y] != ' ':
            raise ValueError

        return (x, y)

    def are_x_y_valid(self, x, y):
        return x >= self.UI.SIZE or y >= self.UI.SIZE or x < 0 or y < 0

    def start(self):
        while self.game_over is False:
            self.UI.print_map()

            self.tick()

    def tick(self):
        try:
            choice = self.input_choice()

        except ValueError:
            self.UI.display('\nInvalid input! Please reenter.\n')
            return

        self.UI.BOARD[choice[0]][choice[1]] = self.UI.X

        if self.is_board_full():
            self.trigger_game_over(None)
            return

        self.AI.attack()

        is_there_a_winner = self.check_for_winner()

        if is_there_a_winner is not False:
            self.trigger_game_over(is_there_a_winner)
            return

    def check_for_winner(self):
        for route in self.winning_routes:
            if all(self.UI.BOARD[coords[0]][coords[1]] == self.UI.X for coords in route):
                return self.UI.X

            if all(self.UI.BOARD[coords[0]][coords[1]] == self.UI.O for coords in route):
                return self.UI.O

        return False

    def is_board_full(self):
        return all(all(block != ' ' for block in line) for line in self.UI.BOARD)

    def trigger_game_over(self, winner):
        self.game_over = True
        self.UI.print_map()
        self.UI.display(self.winner_message.format('Player' if winner == self.UI.X else
                                                   ('Enemy' if winner == self.UI.O else winner)))

    def go(self):
        self.UI.display(self.welcome_message)

        if self.UI.get_input('> ') == 'start':
            self.start()