Upload 8 files

requirements.txt

@@ -1,3 +1,2 @@
-altair
-pandas
-streamlit
+venv\Scriptspygame>=2.1.0
+pytest>=7.0.0

src/game.py

@@ -0,0 +1,254 @@
+import pygame
+import sys
+from levels import *
+
+class Game:
+    def __init__(self, screen):
+        self.screen = screen
+        self.clock = pygame.time.Clock()
+        
+        # Load fonts - try to use more playful fonts if available
+        try:
+            self.font = pygame.font.SysFont('Comic Sans MS', 32)
+            self.small_font = pygame.font.SysFont('Comic Sans MS', 24)
+            self.title_font = pygame.font.SysFont('Comic Sans MS', 48)
+        except:
+            self.font = pygame.font.SysFont('Arial', 32)
+            self.small_font = pygame.font.SysFont('Arial', 24)
+            self.title_font = pygame.font.SysFont('Arial', 48)
+        
+        # Enhanced color palette
+        self.WHITE = (255, 255, 255)
+        self.BLACK = (0, 0, 0)
+        self.GREEN = (76, 175, 80)
+        self.RED = (244, 67, 54)
+        self.BLUE = (33, 150, 243)
+        self.PURPLE = (156, 39, 176)
+        self.BACKGROUND_TOP = (179, 229, 252)  # Light blue
+        self.BACKGROUND_BOTTOM = (255, 255, 255)
+        self.GOLD = (255, 193, 7)
+        
+        # Game state
+        self.current_grade = 1
+        self.score = 0
+        self.lives = 3
+        self.answer_input = ""
+        self.feedback = ""
+        self.feedback_color = self.BLACK
+        self.feedback_scale = 1.0  # For animation
+        
+        # Load heart image for lives or create a heart shape
+        self.heart_points = [
+            (0, -4), (2, -2), (4, -4), (4, -2), (2, 4), (0, 2),
+            (-2, 4), (-4, -2), (-4, -4), (-2, -2)
+        ]
+        self.heart_points = [(x * 3 + 20, y * 3 + 80) for x, y in self.heart_points]
+        
+        # Initialize first problem
+        self.new_problem()
+    
+    def new_problem(self):
+        """Generate a new math problem based on current grade"""
+        self.problem = generate_problem(self.current_grade)
+        self.answer_input = ""
+        self.feedback = ""
+    
+    def handle_events(self):
+        """Handle user input events"""
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+            
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_RETURN and self.answer_input:
+                    self.check_answer()
+                elif event.key == pygame.K_BACKSPACE:
+                    self.answer_input = self.answer_input[:-1]
+                elif event.unicode.isnumeric() or event.unicode == '-':
+                    self.answer_input += event.unicode
+    
+    def check_answer(self):
+        """Check if the provided answer is correct"""
+        try:
+            user_answer = int(self.answer_input)
+            if user_answer == self.problem.answer:
+                self.score += 10 * self.current_grade
+                self.feedback = "Correct!"
+                self.feedback_color = self.GREEN
+                self.feedback_scale = 1.5  # Start larger for "pop" effect
+                
+                # Increase grade if score threshold reached
+                if self.score >= self.current_grade * 100 and self.current_grade < 5:
+                    self.current_grade += 1
+                    self.feedback = f"Level Up! Now at Grade {self.current_grade}"
+                    self.feedback_color = self.GOLD
+                    self.feedback_scale = 2.0  # Even bigger for level up
+            else:
+                self.lives -= 1
+                self.feedback = "Wrong answer!"
+                self.feedback_color = self.RED
+                self.feedback_scale = 1.3  # Slightly larger for wrong answer
+                
+                if self.lives <= 0:
+                    self.game_over()
+            
+            # Draw one frame with the current feedback
+            self.draw()
+            pygame.display.flip()
+            pygame.time.wait(500)  # Show feedback for half a second
+            
+            self.new_problem()
+            
+        except ValueError:
+            self.feedback = "Please enter a valid number"
+            self.feedback_color = self.RED
+            self.feedback_scale = 1.2
+    
+    def game_over(self):
+        """Handle game over state"""
+        waiting = True
+        alpha = 0
+        fade_surface = pygame.Surface((self.screen.get_width(), self.screen.get_height()))
+        fade_surface.fill(self.BLACK)
+        
+        while alpha < 128:  # Fade to semi-transparent black
+            self.draw()  # Draw the game screen underneath
+            fade_surface.set_alpha(alpha)
+            self.screen.blit(fade_surface, (0, 0))
+            pygame.display.flip()
+            alpha += 2
+            pygame.time.wait(5)
+        
+        # Create game over panel
+        panel_width = 400
+        panel_height = 300
+        panel_x = (self.screen.get_width() - panel_width) // 2
+        panel_y = (self.screen.get_height() - panel_height) // 2
+        
+        while waiting:
+            # Draw the base game screen and fade overlay
+            self.draw()
+            fade_surface.set_alpha(128)
+            self.screen.blit(fade_surface, (0, 0))
+            
+            # Draw game over panel
+            pygame.draw.rect(self.screen, self.WHITE, 
+                           (panel_x, panel_y, panel_width, panel_height))
+            pygame.draw.rect(self.screen, self.BLUE, 
+                           (panel_x, panel_y, panel_width, panel_height), 4)
+            
+            # Draw game over text
+            game_over_text = self.title_font.render("Game Over!", True, self.RED)
+            score_text = self.font.render(f"Final Score: {self.score}", True, self.BLACK)
+            grade_text = self.font.render(f"Reached Grade: {self.current_grade}", True, self.BLUE)
+            restart_text = self.small_font.render("Press R to restart or Q to quit", True, self.PURPLE)
+            
+            # Center all text in the panel
+            self.screen.blit(game_over_text, 
+                           game_over_text.get_rect(centerx=panel_x + panel_width // 2, 
+                                                 top=panel_y + 40))
+            self.screen.blit(score_text, 
+                           score_text.get_rect(centerx=panel_x + panel_width // 2, 
+                                             top=panel_y + 120))
+            self.screen.blit(grade_text, 
+                           grade_text.get_rect(centerx=panel_x + panel_width // 2, 
+                                             top=panel_y + 170))
+            self.screen.blit(restart_text, 
+                           restart_text.get_rect(centerx=panel_x + panel_width // 2, 
+                                               top=panel_y + 220))
+            
+            pygame.display.flip()
+            
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    pygame.quit()
+                    sys.exit()
+                if event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_r:
+                        self.__init__(self.screen)
+                        waiting = False
+                    elif event.key == pygame.K_q:
+                        pygame.quit()
+                        sys.exit()
+    
+    def update(self):
+        """Update game state"""
+        self.clock.tick(60)
+    
+    def draw_gradient_background(self):
+        """Draw a gradient background"""
+        height = self.screen.get_height()
+        for i in range(height):
+            progress = i / height
+            color = [int(self.BACKGROUND_TOP[j] * (1 - progress) + self.BACKGROUND_BOTTOM[j] * progress) 
+                    for j in range(3)]
+            pygame.draw.line(self.screen, color, (0, i), (self.screen.get_width(), i))
+    
+    def draw_heart(self, x, y, filled=True):
+        """Draw a heart shape at the specified position"""
+        points = [(px + x - 20, py - 80 + y) for px, py in self.heart_points]
+        if filled:
+            pygame.draw.polygon(self.screen, self.RED, points)
+        pygame.draw.polygon(self.screen, (200, 0, 0), points, 2)
+    
+    def draw(self):
+        """Draw the game screen"""
+        # Draw gradient background
+        self.draw_gradient_background()
+        
+        # Draw decorative header
+        pygame.draw.rect(self.screen, self.BLUE, (0, 0, self.screen.get_width(), 120))
+        pygame.draw.rect(self.screen, self.PURPLE, (0, 115, self.screen.get_width(), 10))
+        
+        # Draw grade and score with enhanced styling
+        grade_text = self.small_font.render(f"Grade: {self.current_grade}", True, self.WHITE)
+        score_text = self.small_font.render(f"Score: {self.score}", True, self.WHITE)
+        
+        self.screen.blit(grade_text, (20, 20))
+        self.screen.blit(score_text, (20, 50))
+        
+        # Draw lives as hearts
+        for i in range(3):
+            self.draw_heart(60 + i * 30, 80, i < self.lives)
+        
+        # Draw problem with a background panel
+        panel_rect = pygame.Rect(250, 150, 300, 250)
+        pygame.draw.rect(self.screen, self.WHITE, panel_rect)
+        pygame.draw.rect(self.screen, self.BLUE, panel_rect, 3)
+        
+        # Draw problem text
+        problem_text = self.font.render(str(self.problem), True, self.BLACK)
+        problem_rect = problem_text.get_rect(centerx=panel_rect.centerx, top=panel_rect.top + 30)
+        self.screen.blit(problem_text, problem_rect)
+        
+        # Draw answer input with a box
+        input_rect = pygame.Rect(panel_rect.left + 20, problem_rect.bottom + 20, 
+                               panel_rect.width - 40, 40)
+        pygame.draw.rect(self.screen, self.WHITE, input_rect)
+        pygame.draw.rect(self.screen, self.BLACK, input_rect, 2)
+        
+        answer_text = self.font.render(f"Answer: {self.answer_input}", True, self.BLACK)
+        answer_rect = answer_text.get_rect(centerx=input_rect.centerx, centery=input_rect.centery)
+        self.screen.blit(answer_text, answer_rect)
+        
+        # Draw feedback with animation
+        if self.feedback:
+            feedback_text = self.font.render(self.feedback, True, self.feedback_color)
+            feedback_rect = feedback_text.get_rect(centerx=panel_rect.centerx, 
+                                                 top=input_rect.bottom + 20)
+            
+            # Apply scale animation
+            scaled_surface = pygame.transform.scale(
+                feedback_text,
+                (int(feedback_text.get_width() * self.feedback_scale),
+                 int(feedback_text.get_height() * self.feedback_scale))
+            )
+            scaled_rect = scaled_surface.get_rect(center=feedback_rect.center)
+            self.screen.blit(scaled_surface, scaled_rect)
+            
+            # Update scale for animation
+            target_scale = 1.0
+            self.feedback_scale += (target_scale - self.feedback_scale) * 0.1
+            if abs(self.feedback_scale - target_scale) < 0.01:
+                self.feedback_scale = target_scale

src/levels.py

@@ -0,0 +1,89 @@
+import random
+from dataclasses import dataclass
+
+@dataclass
+class Problem:
+    num1: int
+    num2: int
+    operator: str
+    answer: int
+    
+    def __str__(self):
+        return f"{self.num1} {self.operator} {self.num2} = ?"
+
+def generate_problem(grade: int) -> Problem:
+    """Generate a math problem appropriate for the given grade level"""
+    
+    if grade == 1:
+        # Grade 1: Simple addition and subtraction with numbers 1-10
+        num1 = random.randint(1, 10)
+        num2 = random.randint(1, 10)
+        operator = random.choice(['+', '-'])
+        
+        # Ensure subtraction doesn't result in negative numbers
+        if operator == '-' and num2 > num1:
+            num1, num2 = num2, num1
+            
+    elif grade == 2:
+        # Grade 2: Addition and subtraction with numbers 1-20
+        num1 = random.randint(1, 20)
+        num2 = random.randint(1, 20)
+        operator = random.choice(['+', '-'])
+        
+        if operator == '-' and num2 > num1:
+            num1, num2 = num2, num1
+            
+    elif grade == 3:
+        # Grade 3: Addition, subtraction with numbers 1-50, and simple multiplication
+        num1 = random.randint(1, 50)
+        operator = random.choice(['+', '-', '*'])
+        
+        if operator == '*':
+            num2 = random.randint(1, 10)
+        else:
+            num2 = random.randint(1, 50)
+            if operator == '-' and num2 > num1:
+                num1, num2 = num2, num1
+                
+    elif grade == 4:
+        # Grade 4: All operations, multiplication with larger numbers
+        num1 = random.randint(1, 100)
+        operator = random.choice(['+', '-', '*', '/'])
+        
+        if operator == '*':
+            num2 = random.randint(1, 12)
+        elif operator == '/':
+            # Generate division problems with whole number answers
+            num2 = random.randint(1, 12)
+            num1 = num2 * random.randint(1, 10)
+        else:
+            num2 = random.randint(1, 100)
+            if operator == '-' and num2 > num1:
+                num1, num2 = num2, num1
+                
+    else:  # grade 5
+        # Grade 5: Larger numbers and more complex operations
+        num1 = random.randint(1, 200)
+        operator = random.choice(['+', '-', '*', '/'])
+        
+        if operator == '*':
+            num2 = random.randint(2, 15)
+        elif operator == '/':
+            num2 = random.randint(2, 15)
+            num1 = num2 * random.randint(1, 20)
+        else:
+            num2 = random.randint(1, 200)
+            if operator == '-' and num2 > num1:
+                num1, num2 = num2, num1
+    
+    # Calculate answer
+    if operator == '+':
+        answer = num1 + num2
+    elif operator == '-':
+        answer = num1 - num2
+    elif operator == '*':
+        answer = num1 * num2
+    else:  # operator == '/'
+        answer = num1 // num2
+    
+    return Problem(num1, num2, operator, answer)

src/main.py

@@ -0,0 +1,26 @@
+import pygame
+import sys
+from game import Game
+
+def main():
+    # Initialize Pygame
+    pygame.init()
+    pygame.font.init()
+    
+    # Set up the display
+    WINDOW_SIZE = (800, 600)
+    screen = pygame.display.set_mode(WINDOW_SIZE)
+    pygame.display.set_caption("Math Adventure - Developed by M.N.F. Zahra - Grade 05 - KM/KM/G.M.M. School")
+    
+    # Create game instance
+    game = Game(screen)
+    
+    # Main game loop
+    while True:
+        game.handle_events()
+        game.update()
+        game.draw()
+        pygame.display.flip()
+
+if __name__ == "__main__":
+    main()

tests/test_game.py

@@ -0,0 +1,82 @@
+import pytest
+import pygame
+from src.game import Game
+
+@pytest.fixture
+def game():
+    pygame.init()
+    screen = pygame.display.set_mode((800, 600))
+    return Game(screen)
+
+def test_game_initialization(game):
+    assert game.current_grade == 1
+    assert game.score == 0
+    assert game.lives == 3
+    assert game.answer_input == ""
+    assert game.feedback == ""
+    assert game.feedback_scale == 1.0  # Test new feedback scale initialization
+
+def test_correct_answer(game):
+    initial_score = game.score
+    game.problem.answer = 42
+    game.answer_input = "42"
+    game.check_answer()
+    assert game.score > initial_score
+    assert game.feedback == "Correct!"
+    assert game.feedback_color == game.GREEN
+    assert game.feedback_scale == 1.5  # Test feedback animation scale
+
+def test_wrong_answer(game):
+    initial_lives = game.lives
+    game.problem.answer = 42
+    game.answer_input = "24"
+    game.check_answer()
+    assert game.lives == initial_lives - 1
+    assert game.feedback == "Wrong answer!"
+    assert game.feedback_color == game.RED
+    assert game.feedback_scale == 1.3  # Test feedback animation scale
+
+def test_invalid_answer(game):
+    game.answer_input = "abc"
+    game.check_answer()
+    assert game.feedback == "Please enter a valid number"
+    assert game.feedback_color == game.RED
+    assert game.feedback_scale == 1.2  # Test feedback animation scale
+
+def test_grade_progression(game):
+    # Set score just below threshold for level up
+    game.score = 99
+    game.current_grade = 1
+    game.problem.answer = 42
+    game.answer_input = "42"
+    game.check_answer()
+    assert game.current_grade == 2
+    assert game.feedback == "Level Up! Now at Grade 2"
+    assert game.feedback_color == game.GOLD  # Test gold color for level up
+    assert game.feedback_scale == 2.0  # Test larger scale for level up
+
+def test_game_over(game):
+    game.lives = 1
+    game.problem.answer = 42
+    game.answer_input = "24"
+    game.check_answer()
+    assert game.lives == 0
+
+def test_ui_colors(game):
+    # Test that all required colors are defined
+    assert hasattr(game, 'WHITE')
+    assert hasattr(game, 'BLACK')
+    assert hasattr(game, 'GREEN')
+    assert hasattr(game, 'RED')
+    assert hasattr(game, 'BLUE')
+    assert hasattr(game, 'PURPLE')
+    assert hasattr(game, 'GOLD')
+    assert hasattr(game, 'BACKGROUND_TOP')
+    assert hasattr(game, 'BACKGROUND_BOTTOM')
+
+def test_heart_shape(game):
+    # Test that heart points are properly initialized
+    assert hasattr(game, 'heart_points')
+    assert len(game.heart_points) > 0
+    # Test that points are properly transformed
+    assert all(isinstance(point, tuple) and len(point) == 2 for point in game.heart_points)

tests/test_levels.py

@@ -0,0 +1,69 @@
+import pytest
+from src.levels import generate_problem, Problem
+
+def test_problem_string_representation():
+    problem = Problem(5, 3, '+', 8)
+    assert str(problem) == "5 + 3 = ?"
+
+def test_grade_1_problem():
+    problem = generate_problem(1)
+    assert problem.num1 <= 10
+    assert problem.num2 <= 10
+    assert problem.operator in ['+', '-']
+    if problem.operator == '-':
+        assert problem.num1 >= problem.num2  # No negative results
+
+def test_grade_2_problem():
+    problem = generate_problem(2)
+    assert problem.num1 <= 20
+    assert problem.num2 <= 20
+    assert problem.operator in ['+', '-']
+    if problem.operator == '-':
+        assert problem.num1 >= problem.num2
+
+def test_grade_3_problem():
+    problem = generate_problem(3)
+    assert problem.num1 <= 50
+    assert problem.operator in ['+', '-', '*']
+    if problem.operator == '*':
+        assert problem.num2 <= 10
+    else:
+        assert problem.num2 <= 50
+        if problem.operator == '-':
+            assert problem.num1 >= problem.num2
+
+def test_grade_4_problem():
+    problem = generate_problem(4)
+    assert problem.num1 <= 100
+    assert problem.operator in ['+', '-', '*', '/']
+    if problem.operator == '*':
+        assert problem.num2 <= 12
+    elif problem.operator == '/':
+        assert problem.num2 <= 12
+        assert problem.num1 % problem.num2 == 0  # Ensure clean division
+    else:
+        assert problem.num2 <= 100
+
+def test_grade_5_problem():
+    problem = generate_problem(5)
+    assert problem.num1 <= 200
+    assert problem.operator in ['+', '-', '*', '/']
+    if problem.operator == '*':
+        assert problem.num2 <= 15
+    elif problem.operator == '/':
+        assert problem.num2 <= 15
+        assert problem.num1 % problem.num2 == 0
+    else:
+        assert problem.num2 <= 200
+
+def test_problem_answers():
+    for grade in range(1, 6):
+        problem = generate_problem(grade)
+        if problem.operator == '+':
+            assert problem.answer == problem.num1 + problem.num2
+        elif problem.operator == '-':
+            assert problem.answer == problem.num1 - problem.num2
+        elif problem.operator == '*':
+            assert problem.answer == problem.num1 * problem.num2
+        elif problem.operator == '/':
+            assert problem.answer == problem.num1 // problem.num2