Add game files and setup for Streamlit deployment

app.py

@@ -2,6 +2,7 @@ import streamlit as st
 import pygame
 import numpy as np
 from pygame.locals import *
+from PIL import Image
 
 # Inicializa o Pygame
 pygame.init()
@@ -45,6 +46,12 @@ def run_game():
         screen.fill((0, 0, 0))
         pygame.draw.rect(screen, player_color, (player_pos[0], player_pos[1], player_size, player_size))
 
+        # Converter a tela do Pygame para uma imagem e exibir no Streamlit
+        image = pygame.surfarray.array3d(pygame.display.get_surface())
+        image = np.rot90(image, 3)
+        image = np.fliplr(image)
+        st.image(image, caption='Jogo em execução', use_column_width=True)
+
         pygame.display.flip()
         clock.tick(30)
 

game.py

@@ -7,7 +7,7 @@ import pandas as pd
 pygame.init()
 
 # Configurações da tela
-screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
+screen = pygame.display.set_mode((640, 480))
 screen_width, screen_height = screen.get_size()
 pygame.display.set_caption("A Jornada do Discípulo")
 
@@ -22,7 +22,7 @@ yellow = (255, 255, 0)
 high_scores = []
 score_file = "assets/high_scores.txt"
 question_file = "assets/questions.xlsx"
-beep_sound = "assets/beep.wav"
+# beep_sound = "assets/beep.wav"  # Comentado, não usaremos som
 congratulations_image_file = "assets/img0.png"  # Caminho para a imagem de parabéns
 score_decrement_interval = 5  # Intervalo de tempo em segundos para subtrair pontos do score
 player_base_speed = 5  # Velocidade base do jogador
@@ -38,10 +38,6 @@ questions = []  # Lista de perguntas
 answered_questions = set()  # Perguntas já respondidas corretamente
 collision_count = 0  # Contador de colisões com obstáculos
 
-# Carregar som de beep
-pygame.mixer.init()
-beep = pygame.mixer.Sound(beep_sound)
-
 # Carregar a imagem de parabéns
 congratulations_image = pygame.image.load(congratulations_image_file)
 congratulations_image = pygame.transform.scale(congratulations_image, (screen_width, screen_height))
@@ -58,376 +54,165 @@ def load_high_scores():
 
 def save_high_scores(scores):
     with open(score_file, "w", encoding="utf-8") as f:
-        for score, date in scores:
-            f.write(f"{score},{date}\n")
+        for score in scores:
+            f.write(",".join(score) + "\n")
 
 def load_questions():
-    global questions
     try:
         df = pd.read_excel(question_file)
-        questions = df.to_dict(orient="records")
+        return df.to_dict(orient="records")
     except FileNotFoundError:
-        questions = [
-            {"pergunta": "Qual é o maior mandamento?", "opcao_1": "Amar a Deus sobre todas as coisas", "opcao_2": "Não matar", "opcao_3": "Guardar o sábado", "opcao_4": "Não roubar", "resposta": "1"}
-        ]
-
-def draw_text(screen, text, size, x, y, align="center", max_width=None):
-    font = pygame.font.Font(pygame.font.match_font('arial'), size)
-    if max_width:
-        words = text.split(' ')
-        lines = []
-        current_line = words[0]
-        for word in words[1:]:
-            if font.size(current_line + ' ' + word)[0] <= max_width:
-                current_line += ' ' + word
-            else:
-                lines.append(current_line)
-                current_line = word
-        lines.append(current_line)
-        for i, line in enumerate(lines):
-            text_surface = font.render(line, True, white)
-            text_rect = text_surface.get_rect()
-            if align == "center":
-                text_rect.midtop = (x, y + i * size)
-            elif align == "left":
-                text_rect.topleft = (x, y + i * size)
-            elif align == "right":
-                text_rect.topright = (x, y + i * size)
-            screen.blit(text_surface, text_rect)
-    else:
-        text_surface = font.render(text, True, white)
-        text_rect = text_surface.get_rect()
-        if align == "center":
-            text_rect.midtop = (x, y)
-        elif align == "left":
-            text_rect.topleft = (x, y)
-        elif align == "right":
-            text_rect.topright = (x, y)
-        screen.blit(text_surface, text_rect)
-
-def move_player(player, speed):
-    global player_velocity, game_start_time
-    keys = pygame.key.get_pressed()
-    if keys[pygame.K_LEFT]:
-        player_velocity.x = -speed
-    elif keys[pygame.K_RIGHT]:
-        player_velocity.x = speed
-    else:
-        player_velocity.x = 0  # Parar se não estiver pressionando esquerda ou direita
-    
-    if keys[pygame.K_UP]:
-        player_velocity.y = -speed
-    elif keys[pygame.K_DOWN]:
-        player_velocity.y = speed
-    else:
-        player_velocity.y = 0  # Parar se não estiver pressionando cima ou baixo
-
-    # Inicia o cronômetro do jogo quando o jogador se move pela primeira vez
-    if player_velocity.x != 0 or player_velocity.y != 0:
-        if game_start_time == 0:
-            game_start_time = time.time()
-
-    # Atualiza a posição do jogador com base na velocidade
-    player.x += player_velocity.x
-    player.y += player_velocity.y
-
-    # Limita o jogador aos limites da tela
-    if player.left < 0:
-        player.left = 0
-        player_velocity.x = 0
-    if player.right > screen_width:
-        player.right = screen_width
-        player_velocity.x = 0
-    if player.top < 100:  # Espaço reservado para o texto da pergunta
-        player.top = 100
-        player_velocity.y = 0
-    if player.bottom > screen_height - 100:  # Espaço reservado para o texto captado
-        player.bottom = screen_height - 100
-        player_velocity.y = 0
-
-def create_level(level_num):
-    num_obstacles = 5 + level_num  # Incrementa a quantidade de obstáculos com o nível
-    items = [pygame.Rect(random.randint(0, screen_width - 20), random.randint(100, screen_height - 120), 20, 20) for _ in range(5)]
-    obstacles = [pygame.Rect(random.randint(0, screen_width - 20), random.randint(100, screen_height - 120), 20, 20) for _ in range(num_obstacles)]
-    item_speeds = [random.uniform(1.0, 2.0) + 0.5 * level_num for _ in range(len(items))]  # Velocidade inicial mais aleatória e aumentada com o nível
-    obstacle_speeds = [random.uniform(1.0, 2.0) + 0.5 * level_num for _ in range(len(obstacles))]  # Velocidade inicial mais aleatória e aumentada com o nível
-    item_directions = [pygame.math.Vector2(random.choice([-1, 1]), random.choice([-1, 1])) for _ in range(len(items))]  # Direção inicial aleatória
-    obstacle_directions = [pygame.math.Vector2(random.choice([-1, 1]), random.choice([-1, 1])) for _ in range(len(obstacles))]  # Direção inicial aleatória
-    health_items = []  # Inicialmente, sem itens de saúde
-    message = f"Bem-vindo ao Nível {level_num}!"
-    return items, obstacles, item_speeds, obstacle_speeds, item_directions, obstacle_directions, health_items, message
-
-def move_objects(objects, speeds, directions):
-    for i, obj in enumerate(objects):
-        # Atualiza a posição com base na velocidade e direção
-        obj.x += speeds[i] * directions[i].x
-        obj.y += speeds[i] * directions[i].y
-        
-        # Altera a direção se atingir as bordas
-        if obj.left < 0 or obj.right > screen_width:
-            directions[i].x *= -1
-        if obj.top < 100 or obj.bottom > screen_height - 100:  # Limita o movimento na área de jogo
-            directions[i].y *= -1
-        
-        # Verifica colisão com outros objetos
-        for j in range(i + 1, len(objects)):
-            if obj.colliderect(objects[j]):
-                directions[i].x *= -1
-                directions[i].y *= -1
-                directions[j].x *= -1
-                directions[j].y *= -1
-
-    return objects, speeds, directions
-
-def handle_collisions(items, obstacles, item_speeds, obstacle_speeds, item_directions, obstacle_directions):
-    for i, item in enumerate(items):
-        for j, obstacle in enumerate(obstacles):
-            if item.colliderect(obstacle):
-                item_directions[i].x *= -1
-                item_directions[i].y *= -1
-                obstacle_directions[j].x *= -1
-                obstacle_directions[j].y *= -1
-
-def show_start_screen():
-    start_time = time.time()
-    countdown = 5
-    font = pygame.font.Font(pygame.font.match_font('arial'), 36)
-    while True:
-        screen.fill(black)
-        current_time = time.time()
-        elapsed_time = current_time - start_time
-        remaining_time = max(0, countdown - int(elapsed_time))
-        
-        if remaining_time == 0:
-            break
-
-        draw_text(screen, f"Preparando para começar! ({remaining_time})", 36, screen_width // 2, screen_height // 2 - 50, align="center")
-
-        pygame.display.flip()
-        pygame.time.Clock().tick(30)
+        return []
 
+# Desenha texto na tela
+def draw_text(surface, text, size, x, y, align="center"):
+    font = pygame.font.Font(None, size)
+    text_surface = font.render(text, True, white)
+    text_rect = text_surface.get_rect()
+    if align == "center":
+        text_rect.midtop = (x, y)
+    elif align == "left":
+        text_rect.topleft = (x, y)
+    surface.blit(text_surface, text_rect)
+
+# Exibe a pergunta na tela
 def show_question(question):
-    draw_text(screen, question["pergunta"], 24, screen_width // 2, 70, align="center", max_width=screen_width - 40)
-    draw_text(screen, f"1. {question['opcao_1']}", 24, screen_width // 2, 110, align="center", max_width=screen_width - 40)
-    draw_text(screen, f"2. {question['opcao_2']}", 24, screen_width // 2, 150, align="center", max_width=screen_width - 40)
-    draw_text(screen, f"3. {question['opcao_3']}", 24, screen_width // 2, 190, align="center", max_width=screen_width - 40)
-    draw_text(screen, f"4. {question['opcao_4']}", 24, screen_width // 2, 230, align="center", max_width=screen_width - 40)
-
-def check_answer(question, answer):
-    correct_answer = str(question["resposta"]).strip()
-    received_answer = str(answer).strip()
-    print(f"Verificando resposta... Esperado: {correct_answer}, Recebido: {received_answer}")  # Mensagem de depuração
-    return correct_answer == received_answer
-
-def get_random_question():
-    global questions, answered_questions
-    if not questions:
-        load_questions()
-    available_questions = [q for q in questions if q["pergunta"] not in answered_questions]
-    if not available_questions:
+    draw_text(screen, question["pergunta"], 24, screen_width // 2, 10, align="center")
+    draw_text(screen, "1: " + question["opcao_1"], 24, screen_width // 2, 40, align="center")
+    draw_text(screen, "2: " + question["opcao_2"], 24, screen_width // 2, 70, align="center")
+    draw_text(screen, "3: " + question["opcao_3"], 24, screen_width // 2, 100, align="center")
+    draw_text(screen, "4: " + question["opcao_4"], 24, screen_width // 2, 130, align="center")
+
+def run_game():
+    global player_speed, correct_answers_streak, correct_answers, player_velocity, game_start_time, start_time, questions, answered_questions, collision_count
+    
+    high_scores = load_high_scores()
+    questions = load_questions()
+
+    player_pos = pygame.math.Vector2(screen_width // 2, screen_height // 2)
+    player_velocity = pygame.math.Vector2(0, 0)
+    player_health = 3
+    score = 0
+    level_num = 1
+    collision_count = 0
+
+    obstacles = []
+    health_items = []
+    current_question = None
+    answer_start_time = None
+
+    def get_new_question():
+        available_questions = [q for q in questions if q["pergunta"] not in answered_questions]
+        if available_questions:
+            return random.choice(available_questions)
         return None
-    question = random.choice(available_questions)
-    return question
 
-def show_congratulations_screen():
-    screen.blit(congratulations_image, (0, 0))
-    pygame.display.flip()
-    time.sleep(30)
+    clock = pygame.time.Clock()
+    game_start_time = time.time()
+    start_time = game_start_time
 
-# Carregar perguntas
-load_questions()
-
-# Objetos do jogo
-player = pygame.Rect(screen_width // 2, screen_height // 2, player_radius * 2, player_radius * 2)
-player_health = 3
-level_num = 1
-items, obstacles, item_speeds, obstacle_speeds, item_directions, obstacle_directions, health_items, message = create_level(level_num)
-score = 10  # Começar com 10 pontos de score
-health_spawn_time = time.time()  # Tempo inicial para o spawn de vida
-current_question = None
-
-# Carregar os melhores scores
-high_scores = load_high_scores()
-
-# Tela Inicial
-show_start_screen()
-
-# Loop principal do jogo
-running = True
-clock = pygame.time.Clock()
-
-print("Iniciando o loop principal...")  # Mensagem de depuração
-
-while running:
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            running = False
-        elif event.type == pygame.KEYDOWN:
-            if current_question:
-                if event.key == pygame.K_1:
-                    answer = "1"
-                elif event.key == pygame.K_2:
-                    answer = "2"
-                elif event.key == pygame.K_3:
-                    answer = "3"
-                elif event.key == pygame.K_4:
-                    answer = "4"
-                else:
-                    answer = None
-
-                if answer:
-                    if check_answer(current_question, answer):
-                        score += 3
-                        correct_answers += 1
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_ESCAPE:
+                    running = False
+                elif current_question and event.key in [pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4]:
+                    selected_option = int(event.unicode)
+                    if selected_option == current_question["resposta"]:
                         correct_answers_streak += 1
+                        correct_answers += 1
+                        score += 10 * level_num
+                        # beep.play()  # Comentado, não usaremos som
+                        answer_start_time = None
                         answered_questions.add(current_question["pergunta"])
-                        print(f"Resposta correta! Streak: {correct_answers_streak}, Total corretas: {correct_answers}")  # Mensagem de depuração
-                        obstacles_to_remove = 1
-                        if level_num > 5:
-                            obstacles_to_remove = 2
-                        if level_num > 8:
-                            obstacles_to_remove = 3
-                        if obstacles:
-                            for _ in range(min(obstacles_to_remove, len(obstacles))):
-                                idx = random.randint(0, len(obstacles) - 1)
-                                obstacles.pop(idx)
-                                obstacle_speeds.pop(idx)
-                                obstacle_directions.pop(idx)
-                        if correct_answers_streak >= 3:
-                            player_health += 1
-                            correct_answers_streak = 0  # Reinicia a contagem de respostas corretas
-                        current_question = None
-                        beep.play()  # Beep sonoro
-                        if len(answered_questions) == len(questions):
-                            show_congratulations_screen()
-                            running = False
+                        current_question = get_new_question()
                     else:
-                        correct_answers_streak = 0  # Reinicia a contagem de respostas corretas
-                        score -= 1
-                        print("Resposta incorreta.")  # Mensagem de depuração
-                        for _ in range(3):
-                            obstacles.append(pygame.Rect(random.randint(0, screen_width - 20), random.randint(100, screen_height - 120), 20, 20))
-                            obstacle_speeds.append(random.uniform(1.0, 2.0) + 0.5 * level_num)
-                            obstacle_directions.append(pygame.math.Vector2(random.choice([-1, 1]), random.choice([-1, 1])))
-                        current_question = None
-
-    # Movimento do jogador
-    move_player(player, player_speed)
-
-    # Verifica colisão com itens
-    for item in items[:]:
-        if player.colliderect(item):
-            items.remove(item)
-            score += 1
-            current_question = get_random_question()
-            if not current_question:
-                show_congratulations_screen()
-                running = False
-                break
-            print(f"Nova pergunta: {current_question['pergunta']}")  # Mensagem de depuração
-
-    # Verifica colisão com obstáculos
-    for obstacle in obstacles[:]:
-        if player.colliderect(obstacle):
-            player_health -= 1
-            collision_count += 1
-            idx = obstacles.index(obstacle)
-            obstacles.remove(obstacle)
-            obstacle_speeds.pop(idx)
-            obstacle_directions.pop(idx)
-            print(f"Colidiu com obstáculo. Vidas restantes: {player_health}")  # Mensagem de depuração
-            if player_health <= 0 or score <= 0:
-                running = False
-                message = "Game Over"
-                print(message)  # Mensagem de depuração
-
-    # Verifica colisão com itens de saúde
-    for health_item in health_items[:]:
-        if player.colliderect(health_item):
-            health_items.remove(health_item)
-            player_health += 1
-
-    # Verifica se o nível foi concluído
-    if not items:
-        level_num += 1
-        items, obstacles, item_speeds, obstacle_speeds, item_directions, obstacle_directions, health_items, message = create_level(level_num)
-        player_radius += 2  # Aumenta o raio do jogador a cada nível
-        player = pygame.Rect(player.x, player.y, player_radius * 2, player_radius * 2)
-        player_speed = player_base_speed + level_num * player_speed_increment  # Incrementa a velocidade do jogador com o nível
-        print(f"Iniciando nível {level_num}")  # Mensagem de depuração
-
-    # Movimento dos itens e obstáculos
-    items, item_speeds, item_directions = move_objects(items, item_speeds, item_directions)
-    obstacles, obstacle_speeds, obstacle_directions = move_objects(obstacles, obstacle_speeds, obstacle_directions)
-    
-    # Tratamento de colisões entre itens e obstáculos
-    handle_collisions(items, obstacles, item_speeds, obstacle_speeds, item_directions, obstacle_directions)
-
-    # Aparição aleatória de itens de saúde
-    if level_num > 5 and time.time() - health_spawn_time > random.randint(10, 20):
-        health_items = [pygame.Rect(random.randint(0, screen_width - 20), random.randint(100, screen_height - 120), 20, 20)]
-        health_spawn_time = time.time()
-
-    # Remover itens de saúde após 5 segundos
-    if health_items and time.time() - health_spawn_time > 5:
-        health_items = []
-
-    # Cronômetro para subtrair pontos do score a cada intervalo de tempo
-    current_time = time.time()
-    if current_time - start_time >= score_decrement_interval:
-        if score > 0:  # Apenas decrementar se o score for maior que 0
+                        correct_answers_streak = 0
+                        player_health -= 1
+                        if player_health <= 0:
+                            running = False
+
+        keys = pygame.key.get_pressed()
+        if keys[pygame.K_LEFT]:
+            player_velocity.x = -player_speed
+        elif keys[pygame.K_RIGHT]:
+            player_velocity.x = player_speed
+        else:
+            player_velocity.x = 0
+
+        if keys[pygame.K_UP]:
+            player_velocity.y = -player_speed
+        elif keys[pygame.K_DOWN]:
+            player_velocity.y = player_speed
+        else:
+            player_velocity.y = 0
+
+        player_pos += player_velocity
+
+        if player_pos.x < 0:
+            player_pos.x = 0
+        elif player_pos.x > screen_width:
+            player_pos.x = screen_width
+
+        if player_pos.y < 0:
+            player_pos.y = 0
+        elif player_pos.y > screen_height:
+            player_pos.y = screen_height
+
+        if time.time() - start_time >= score_decrement_interval:
             score -= 1
-        start_time = current_time  # Reseta o tempo
-        print(f"Score atualizado: {score}")  # Mensagem de depuração
-        if score <= 0:
-            running = False
-            message = "Game Over"
-            print(message)  # Mensagem de depuração
-
-    # Desenha na tela
+            start_time = time.time()
+
+        if not current_question:
+            current_question = get_new_question()
+            answer_start_time = time.time()
+
+        if current_question and time.time() - answer_start_time > 10:
+            current_question = get_new_question()
+            answer_start_time = time.time()
+
+        screen.fill(black)
+
+        pygame.draw.circle(screen, green, (int(player_pos.x), int(player_pos.y)), player_radius)
+
+        for obstacle in obstacles:
+            pygame.draw.rect(screen, red, obstacle)
+        for health_item in health_items:
+            pygame.draw.rect(screen, yellow, health_item)
+
+        draw_text(screen, f"Pontos: {score}", 24, 10, 10, align="left")
+        draw_text(screen, f"Vidas: {player_health}", 24, 10, 40, align="left")
+        draw_text(screen, f"Nível: {level_num}", 24, 10, 70, align="left")
+        draw_text(screen, f"Colisões: {collision_count}", 24, 10, 100, align="left")
+
+        if current_question:
+            show_question(current_question)
+
+        pygame.display.flip()
+        clock.tick(30)
+
+    date_str = time.strftime("%Y-%m-%d %H:%M:%S")
+    high_scores.append([str(score), date_str])
+    high_scores = sorted(high_scores, key=lambda x: int(x[0]), reverse=True)[:10]
+    save_high_scores(high_scores)
+
+    duration_seconds = int(time.time() - game_start_time)
+    duration_minutes = duration_seconds // 60
+    duration_seconds = duration_seconds % 60
+    duration_formatted = f"{duration_minutes:02}:{duration_seconds:02}"
+
     screen.fill(black)
-    pygame.draw.circle(screen, green, player.center, player_radius)
-    for item in items:
-        pygame.draw.rect(screen, white, item)
-    for obstacle in obstacles:
-        pygame.draw.rect(screen, red, obstacle)
-    for health_item in health_items:
-        pygame.draw.rect(screen, yellow, health_item)
-    
-    # Exibe a pontuação, número de vidas, nível atual e contagem de colisões
-    draw_text(screen, f"Pontos: {score}", 24, 10, 10, align="left")
-    draw_text(screen, f"Vidas: {player_health}", 24, 10, 40, align="left")
-    draw_text(screen, f"Nível: {level_num}", 24, 10, 70, align="left")
-    draw_text(screen, f"Colisões: {collision_count}", 24, 10, 100, align="left")
-    
-    # Exibe a pergunta na parte superior da tela
-    if current_question:
-        show_question(current_question)
-    
+    draw_text(screen, "Game Over", 48, screen_width // 2, screen_height // 2 - 100, align="center")
+    draw_text(screen, f"Pontuação Final: {score}", 36, screen_width // 2, screen_height // 2 - 50, align="center")
+    draw_text(screen, f"Nível Final: {level_num}", 36, screen_width // 2, screen_height // 2, align="center")
+    draw_text(screen, f"Duração da Partida: {duration_formatted}", 36, screen_width // 2, screen_height // 2 + 50, align="center")
+    draw_text(screen, f"Respostas Corretas: {correct_answers}", 36, screen_width // 2, screen_height // 2 + 100, align="center")
+    draw_text(screen, f"Colisões: {collision_count}", 36, screen_width // 2, screen_height // 2 + 150, align="center")
     pygame.display.flip()
-    clock.tick(30)
-
-# Atualiza os melhores scores
-date_str = time.strftime("%Y-%m-%d %H:%M:%S")
-high_scores.append([str(score), date_str])
-high_scores = sorted(high_scores, key=lambda x: int(x[0]), reverse=True)[:10]
-save_high_scores(high_scores)
-
-# Exibe a tela de Game Over com os resultados
-duration_seconds = int(time.time() - game_start_time)
-duration_minutes = duration_seconds // 60
-duration_seconds = duration_seconds % 60
-duration_formatted = f"{duration_minutes:02}:{duration_seconds:02}"
-
-screen.fill(black)
-draw_text(screen, "Game Over", 48, screen_width // 2, screen_height // 2 - 100, align="center")
-draw_text(screen, f"Pontuação Final: {score}", 36, screen_width // 2, screen_height // 2 - 50, align="center")
-draw_text(screen, f"Nível Final: {level_num}", 36, screen_width // 2, screen_height // 2, align="center")
-draw_text(screen, f"Duração da Partida: {duration_formatted}", 36, screen_width // 2, screen_height // 2 + 50, align="center")
-draw_text(screen, f"Respostas Corretas: {correct_answers}", 36, screen_width // 2, screen_height // 2 + 100, align="center")
-draw_text(screen, f"Colisões: {collision_count}", 36, screen_width // 2, screen_height // 2 + 150, align="center")
-pygame.display.flip()
-time.sleep(30)
-
-pygame.quit()
-print("Jogo encerrado.")  # Mensagem de depuração
+    time.sleep(30)
+
+    pygame.quit()
+    print("Jogo encerrado.")  # Mensagem de depuração