Add game files and setup for Streamlit deployment

app.py

@@ -0,0 +1,13 @@
+import streamlit as st
+import subprocess
+
+def main():
+    st.title('A Jornada do Discípulo')
+
+    if st.button('Iniciar Jogo'):
+        st.write("O jogo será iniciado em uma nova janela.")
+        process = subprocess.Popen(["python", "game_huggingface.py"])
+        process.communicate()
+
+if __name__ == "__main__":
+    main()

assets/high_scores.txt

@@ -0,0 +1,10 @@
+300,2024-07-25 00:51:28
+281,2024-07-25 01:32:56
+265,2024-07-25 01:27:30
+250,2024-07-25 01:20:13
+92,2024-07-25 02:01:36
+33,2024-07-25 01:48:32
+31,2024-07-25 00:01:11
+29,2024-07-24 23:51:36
+25,2024-07-24 23:45:54
+25,2024-07-25 01:12:04

game.py

@@ -0,0 +1,433 @@
+import pygame
+import random
+import time
+import pandas as pd
+
+# Inicializa o Pygame
+pygame.init()
+
+# Configurações da tela
+screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
+screen_width, screen_height = screen.get_size()
+pygame.display.set_caption("A Jornada do Discípulo")
+
+# Cores
+white = (255, 255, 255)
+black = (0, 0, 0)
+green = (0, 255, 0)
+red = (255, 0, 0)
+yellow = (255, 255, 0)
+
+# Configurações do jogo
+high_scores = []
+score_file = "high_scores.txt"
+question_file = "questions.xlsx"
+beep_sound = "beep.wav"
+congratulations_image_file = "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
+player_speed_increment = 0.5  # Incremento de velocidade do jogador
+player_speed = player_base_speed  # Velocidade atual do jogador
+player_radius = 25  # Raio inicial do jogador
+correct_answers_streak = 0  # Contador de perguntas corretas consecutivas
+correct_answers = 0  # Contador total de perguntas corretas
+player_velocity = pygame.math.Vector2(0, 0)  # Velocidade inicial do jogador
+game_start_time = 0  # Tempo inicial da partida
+start_time = 0  # Tempo inicial para o cronômetro de score
+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))
+
+# Semente aleatória para garantir aleatoriedade
+random.seed(time.time())
+
+def load_high_scores():
+    try:
+        with open(score_file, "r", encoding="utf-8") as f:
+            return [line.strip().split(",") for line in f.readlines() if line.strip()]
+    except FileNotFoundError:
+        return []
+
+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")
+
+def load_questions():
+    global questions
+    try:
+        df = pd.read_excel(question_file)
+        questions = 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)
+
+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:
+        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)
+
+# 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
+                        correct_answers_streak += 1
+                        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
+                    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
+            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
+    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)
+    
+    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

requirements.txt

@@ -0,0 +1,4 @@
+pygame
+pandas
+openpyxl
+streamlit