gh-space-shooter 0.0.1__py3-none-any.whl

gh_space_shooter/game/drawables/ship.py

@@ -0,0 +1,107 @@
+"""Player ship object."""
+
+from typing import TYPE_CHECKING
+
+from PIL import ImageDraw
+
+from ...constants import SHIP_POSITION_Y, SHIP_SPEED
+from .drawable import Drawable
+
+if TYPE_CHECKING:
+    from ..game_state import GameState
+    from ..render_context import RenderContext
+
+
+class Ship(Drawable):
+    """Represents the player's ship."""
+
+    def __init__(self, game_state: "GameState"):
+        """Initialize the ship at starting position."""
+        self.x: float = 25  # Start middle of screen
+        self.target_x = self.x
+        self.shoot_cooldown = 0  # Frames until ship can shoot again
+        self.game_state = game_state
+
+    def move_to(self, x: int):
+        """
+        Move ship to a new x position.
+
+        Args:
+            x: Target x position
+        """
+        self.target_x = x
+
+    def is_moving(self) -> bool:
+        """Check if ship is moving to a new position."""
+        return self.x != self.target_x
+
+    def can_shoot(self) -> bool:
+        """Check if ship can shoot (cooldown has finished)."""
+        return self.shoot_cooldown == 0
+
+    def animate(self) -> None:
+        """Update ship position, moving toward target at constant speed."""
+        if self.x < self.target_x:
+            self.x = min(self.x + SHIP_SPEED, self.target_x)
+        elif self.x > self.target_x:
+            self.x = max(self.x - SHIP_SPEED, self.target_x)
+
+        # Decrement shoot cooldown
+        if self.shoot_cooldown > 0:
+            self.shoot_cooldown -= 1
+
+    def draw(self, draw: ImageDraw.ImageDraw, context: "RenderContext") -> None:
+        """Draw a simple Galaga-style ship."""
+        x, y = context.get_cell_position(self.x, SHIP_POSITION_Y)
+
+        # Calculate ship dimensions
+        center_x = x + context.cell_size // 2
+        height = context.cell_size
+        wing_width = 8
+
+        # Draw left wing
+        draw.polygon(
+            [
+                (center_x - 2, y + height * 0.5),
+                (center_x - wing_width, y + height * 0.8),
+                (center_x - wing_width, y + height * 1),
+                (center_x - 2, y + height * 0.7),
+            ],
+            fill=(*context.ship_color, 128)
+        )
+        draw.rectangle(
+            [
+                center_x - wing_width - 1, y + height * 0.5,
+                center_x - wing_width, y + height * 1, 
+            ],
+            fill=context.ship_color
+        )
+
+        # Draw right wing
+        draw.polygon(
+            [
+                (center_x + 2, y + height * 0.5),
+                (center_x + wing_width, y + height * 0.8),
+                (center_x + wing_width, y + height * 1),
+                (center_x + 2, y + height * 0.7),
+            ],
+            fill=(*context.ship_color, 128)
+        )
+        draw.rectangle(
+            [
+                center_x + wing_width, y + height * 0.5, 
+                center_x + wing_width + 1, y + height * 1
+            ],
+            fill=context.ship_color
+        )
+
+
+        draw.polygon(
+            [
+                (center_x, y),
+                (center_x - 3, y + height * 0.7),
+                (center_x, y + height),
+                (center_x + 3, y + height * 0.7),
+            ],
+            fill=context.ship_color
+        )

gh_space_shooter/game/drawables/starfield.py

@@ -0,0 +1,65 @@
+"""Animated starfield background."""
+
+import random
+from typing import TYPE_CHECKING
+
+from PIL import ImageDraw
+
+from ...constants import NUM_WEEKS, SHIP_POSITION_Y
+from .drawable import Drawable
+
+if TYPE_CHECKING:
+    from ..render_context import RenderContext
+
+
+class Starfield(Drawable):
+    """Animated starfield background with slowly moving stars."""
+
+    def __init__(self):
+        """Initialize the starfield with random stars."""
+        self.stars = []
+        # Generate about 100 stars across the play area
+        for _ in range(100):
+            # Random position across the entire grid area
+            x = random.uniform(-2, NUM_WEEKS + 2)
+            y = random.uniform(-2, SHIP_POSITION_Y + 4)
+            # Brightness: 0.2 to 1.0 (dimmer stars for depth)
+            brightness = random.uniform(0.2, 1.0)
+            # Size: 1-2 pixels
+            size = random.choice([1, 1, 1, 2])  # More 1-pixel stars
+            # Speed: slower for dimmer (farther) stars
+            speed = 0.02 + (brightness * 0.03)  # 0.02-0.05 cells per frame
+            self.stars.append([x, y, brightness, size, speed])
+
+    def animate(self) -> None:
+        """Move stars downward, wrapping around when they go off screen."""
+        for star in self.stars:
+            # star[1] is the y position, star[4] is the speed
+            star[1] += star[4]
+
+            # Wrap around: if star goes below the screen, move it back to the top
+            if star[1] > SHIP_POSITION_Y + 4:
+                star[1] = -2
+                # Randomize x position when wrapping for variety
+                star[0] = random.uniform(-2, NUM_WEEKS + 2)
+
+    def draw(self, draw: ImageDraw.ImageDraw, context: "RenderContext") -> None:
+        """Draw all stars at their current positions."""
+        for star_x, star_y, brightness, size, _ in self.stars:
+            # Convert grid position to pixel position
+            x, y = context.get_cell_position(star_x, star_y)
+
+            # Calculate star color (white with varying brightness)
+            star_brightness = int(255 * brightness)
+            star_color = (star_brightness, star_brightness, star_brightness, 255)
+
+            # Draw star as a small rectangle or point
+            if size == 1:
+                # Single pixel star
+                draw.point([(x, y)], fill=star_color)
+            else:
+                # Slightly larger star (2x2)
+                draw.rectangle(
+                    [x, y, x + size - 1, y + size - 1],
+                    fill=star_color
+                )

gh_space_shooter/game/game_state.py

@@ -0,0 +1,80 @@
+"""Game state management for tracking enemies, ship, and bullets."""
+
+from typing import TYPE_CHECKING, List
+
+from PIL import ImageDraw
+
+from ..constants import SHIP_SHOOT_COOLDOWN_FRAMES
+from ..github_client import ContributionData
+from .drawables import Bullet, Drawable, Enemy, Explosion, Ship, Starfield
+
+if TYPE_CHECKING:
+    from .render_context import RenderContext
+
+
+class GameState(Drawable):
+    """Manages the current state of the game."""
+
+    def __init__(self, contribution_data: ContributionData):
+        """
+        Initialize game state from contribution data.
+
+        Args:
+            contribution_data: The GitHub contribution data
+        """
+        self.starfield = Starfield()
+        self.ship = Ship(self)
+        self.enemies: List[Enemy] = []
+        self.bullets: List[Bullet] = []
+        self.explosions: List[Explosion] = []
+
+        self._initialize_enemies(contribution_data)
+
+    def _initialize_enemies(self, contribution_data: ContributionData):
+        """Create enemies based on contribution levels."""
+        weeks = contribution_data["weeks"]
+        for week_idx, week in enumerate(weeks):
+            for day_idx, day in enumerate(week["days"]):
+                level = day["level"]
+                if level <= 0:
+                    continue
+                enemy = Enemy(x=week_idx, y=day_idx, health=level, game_state=self)
+                self.enemies.append(enemy)
+
+    def shoot(self) -> None:
+        """
+        Ship shoots a bullet and starts cooldown timer.
+        """
+        bullet = Bullet(int(self.ship.x), game_state=self)
+        self.bullets.append(bullet)
+        self.ship.shoot_cooldown = SHIP_SHOOT_COOLDOWN_FRAMES
+
+    def is_complete(self) -> bool:
+        """Check if game is complete (all enemies destroyed)."""
+        return len(self.enemies) == 0
+
+    def can_take_action(self) -> bool:
+        """Check if ship can take an action (not moving and can shoot)."""
+        return not self.ship.is_moving() and self.ship.can_shoot()
+
+    def animate(self) -> None:
+        """Update all game objects for next frame."""
+        self.starfield.animate()
+        self.ship.animate()
+        for enemy in self.enemies:
+            enemy.animate()
+        for bullet in self.bullets:
+            bullet.animate()
+        for explosion in self.explosions:
+            explosion.animate()
+
+    def draw(self, draw: ImageDraw.ImageDraw, context: "RenderContext") -> None:
+        """Draw all game objects including the grid."""
+        self.starfield.draw(draw, context)
+        for enemy in self.enemies:
+            enemy.draw(draw, context)
+        for explosion in self.explosions:
+            explosion.draw(draw, context)
+        for bullet in self.bullets:
+            bullet.draw(draw, context)
+        self.ship.draw(draw, context)

gh_space_shooter/game/render_context.py

@@ -0,0 +1,56 @@
+"""Rendering context for drawable objects."""
+
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class RenderContext:
+    """
+    Context providing rendering helpers and constants to drawable objects.
+
+    This encapsulates all the information needed to render game objects,
+    including colors, sizes, and helper functions. Can be extended for theming.
+    """
+
+    # Size constants
+    cell_size: int
+    cell_spacing: int
+    padding: int
+
+    # Colors - can be customized for different themes
+    background_color: Tuple[int, int, int]
+    grid_color: Tuple[int, int, int]
+    ship_color: Tuple[int, int, int]
+    bullet_color: Tuple[int, int, int]
+    enemy_colors: dict[int, Tuple[int, int, int]]  # Maps health level to color
+
+    def get_cell_position(self, x: float, y: float) -> tuple[float, float]:
+        """
+        Get the pixel position (x, y) for a grid coordinate.
+
+        Args:
+            week: Week position (0-51, can be fractional for smooth animation)
+            day: Day position (0-6, can be fractional for smooth animation)
+
+        Returns:
+            Tuple of (x, y) pixel coordinates
+        """
+        return (
+            self.padding + x * (self.cell_size + self.cell_spacing),
+            self.padding + y * (self.cell_size + self.cell_spacing),
+        )
+
+    @staticmethod
+    def darkmode() -> "RenderContext":
+        """Predefined dark mode rendering context."""
+        return RenderContext(
+            cell_size=12,
+            cell_spacing=3,
+            padding=40,
+            background_color=(13, 17, 23),
+            grid_color=(22, 27, 34),
+            enemy_colors={1: (0, 109, 50), 2: (38, 166, 65), 3: (57, 211, 83), 4: (87, 242, 135)},
+            ship_color=(68, 147, 248),
+            bullet_color=(255, 223, 0),
+        )

gh_space_shooter/game/renderer.py

@@ -0,0 +1,44 @@
+"""Renderer for drawing game frames using Pillow."""
+
+from PIL import Image, ImageDraw
+
+from ..constants import NUM_WEEKS, SHIP_POSITION_Y
+from .game_state import GameState
+from .render_context import RenderContext
+
+class Renderer:
+    """Renders game state as PIL Images."""
+    def __init__(self, game_state: GameState, render_context: RenderContext):
+        """
+        Initialize renderer.
+
+        Args:
+            game_state: The game state to render
+            render_context: Rendering configuration and theming
+        """
+        self.game_state = game_state
+
+        self.context = render_context
+
+        self.grid_width = NUM_WEEKS * (self.context.cell_size + self.context.cell_spacing)
+        self.grid_height = SHIP_POSITION_Y * (self.context.cell_size + self.context.cell_spacing)
+        self.width = self.grid_width + 2 * self.context.padding
+        self.height = self.grid_height + 2 * self.context.padding
+
+    def render_frame(self) -> Image.Image:
+        """
+        Render the current game state as an image.
+
+        Returns:
+            PIL Image of the current frame
+        """
+        # Create image with background color
+        img = Image.new("RGB", (self.width, self.height), self.context.background_color)
+        
+        # Draw game state
+        overlay = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(overlay, "RGBA")
+        self.game_state.draw(draw, self.context)
+        combined = Image.alpha_composite(img.convert("RGBA"), overlay)
+        
+        return combined.convert("RGB").convert("P", palette=Image.Palette.ADAPTIVE)

gh_space_shooter/game/strategies/__init__.py

@@ -0,0 +1,14 @@
+"""Strategy implementations for enemy clearing."""
+
+from .base_strategy import Action, BaseStrategy
+from .column_strategy import ColumnStrategy
+from .random_strategy import RandomStrategy
+from .row_strategy import RowStrategy
+
+__all__ = [
+    "BaseStrategy",
+    "Action",
+    "ColumnStrategy",
+    "RowStrategy",
+    "RandomStrategy",
+]

gh_space_shooter/game/strategies/base_strategy.py

@@ -0,0 +1,43 @@
+"""Base strategy interface for enemy clearing strategies."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Iterator
+
+if TYPE_CHECKING:
+    from ..game_state import GameState
+
+
+class Action:
+    """Represents a single action in the game."""
+
+    def __init__(self, x: int, shoot: bool = False):
+        """
+        Initialize an action.
+
+        Args:
+            x: Week position (0-51) where ship should move
+            shoot: Whether to shoot at this position
+        """
+        self.x = x
+        self.shoot = shoot
+
+    def __repr__(self) -> str:
+        action_type = "SHOOT" if self.shoot else "MOVE"
+        return f"Action({action_type} x={self.x})"
+
+
+class BaseStrategy(ABC):
+    """Abstract base class for enemy clearing strategies."""
+
+    @abstractmethod
+    def generate_actions(self, game_state: "GameState") -> Iterator[Action]:
+        """
+        Generate sequence of actions for the ship to clear enemies.
+
+        Args:
+            game_state: The current game state with enemies, ship, and bullets
+
+        Yields:
+            Action objects representing ship movements and shots
+        """
+        pass

gh_space_shooter/game/strategies/column_strategy.py

@@ -0,0 +1,46 @@
+"""Column-by-column strategy: Ship moves week by week (left to right)."""
+
+from typing import TYPE_CHECKING, Iterator
+
+from ...constants import NUM_WEEKS
+from .base_strategy import Action, BaseStrategy
+
+if TYPE_CHECKING:
+    from ..game_state import GameState
+
+
+class ColumnStrategy(BaseStrategy):
+    """
+    Ship moves column by column (week by week) from left to right.
+
+    For each week, the ship shoots at all enemies in that column until destroyed,
+    reacting to the actual game state rather than planning ahead.
+    """
+
+    def generate_actions(self, game_state: "GameState") -> Iterator[Action]:
+        """
+        Generate actions moving week by week, reacting to living enemies.
+
+        The ship moves through each week (column), shooting at enemies
+        until all enemies in that week are destroyed, then moves to the next week.
+        Uses actual game state to determine which enemies are still alive.
+
+        Args:
+            game_state: The current game state with living enemies
+
+        Yields:
+            Action objects representing ship movements and shots
+        """
+        # Process each week (column) from left to right
+        for week_idx in range(NUM_WEEKS):
+            # Keep shooting at enemies in this week until none remain
+            while True:
+                # Find all living enemies in this week
+                enemies_in_week = [e for e in game_state.enemies if e.x == week_idx]
+                total_health = sum(e.health for e in enemies_in_week)
+                flying_bullets = len([b for b in game_state.bullets if int(b.x) == week_idx])
+
+                if flying_bullets >= total_health:
+                    break
+
+                yield Action(x=week_idx, shoot=True)

gh_space_shooter/game/strategies/random_strategy.py

@@ -0,0 +1,61 @@
+"""Random strategy: Pick random columns and shoot from bottom up."""
+
+import random
+from typing import TYPE_CHECKING, Iterator
+
+from .base_strategy import Action, BaseStrategy
+
+if TYPE_CHECKING:
+    from ..game_state import GameState
+
+
+class RandomStrategy(BaseStrategy):
+    """
+    Ship uses weighted random selection to pick columns based on distance.
+
+    Takes the 8 closest columns and applies distance-based weights for selection,
+    creating a balanced mix of efficiency and unpredictability.
+    """
+
+    def generate_actions(self, game_state: "GameState") -> Iterator[Action]:
+        """
+        Generate actions using weighted random selection based on distance.
+
+        Sorts columns by distance, takes the 8 closest, and applies weights:
+        - Distance 0 (same position): weight 3
+        - Distance 1-3: weight 5 (highest priority)
+        - Distance 4+: weight 1 (lowest priority)
+
+        Args:
+            game_state: The current game state with living enemies
+
+        Yields:
+            Action objects representing ship movements and shots
+        """
+        while game_state.enemies:
+            columns_with_enemies = list(set(e.x for e in game_state.enemies))
+            ship_x = game_state.ship.x
+
+            # Take the first 8 closest columns
+            columns_by_distance = sorted(columns_with_enemies, key=lambda col: abs(col - ship_x))
+            candidate_columns = columns_by_distance[:8]
+
+            # Assign weights based on distance
+            weights = []
+            for col in candidate_columns:
+                distance = abs(col - ship_x)
+                if distance == 0:
+                    weights.append(10)
+                elif 1 <= distance <= 3:
+                    weights.append(100)
+                else:  # distance >= 4
+                    weights.append(1)
+
+            # Choose randomly with weights
+            target_column = random.choices(candidate_columns, weights=weights)[0]
+
+            enemies_in_column = [e for e in game_state.enemies if e.x == target_column]
+            lowest_enemy = max(enemies_in_column, key=lambda e: e.y)
+
+            for _ in range(lowest_enemy.health):
+                yield Action(x=target_column, shoot=True)

gh_space_shooter/game/strategies/row_strategy.py

@@ -0,0 +1,41 @@
+"""Row-by-row strategy: Process enemies row by row (day by day)."""
+
+from typing import TYPE_CHECKING, Iterator
+
+from ...constants import NUM_DAYS
+from .base_strategy import Action, BaseStrategy
+
+if TYPE_CHECKING:
+    from ..game_state import GameState
+
+
+class RowStrategy(BaseStrategy):
+    """
+    Ship processes enemies row by row (day by day) from top to bottom.
+
+    For each row (day), the ship moves to each enemy position in that row
+    and shoots until all enemies in the row are destroyed.
+    """
+
+    def generate_actions(self, game_state: "GameState") -> Iterator[Action]:
+        """
+        Generate actions processing enemies row by row.
+
+        The ship processes each day (row) from Sunday (0) to Saturday (6),
+        moving horizontally to shoot at all enemies in that row before
+        proceeding to the next row.
+
+        Args:
+            game_state: The current game state with living enemies
+
+        Yields:
+            Action objects representing ship movements and shots
+        """
+        # Process each day (row) from top to bottom
+        for day_idx in range(NUM_DAYS - 1, -1, -1):
+            enemies_in_row = [e for e in game_state.enemies if e.y == day_idx]
+            enemies_in_row.sort(key=lambda e: e.x * (day_idx % 2 * 2 - 1)) # zig-zag
+
+            for enemy in enemies_in_row:
+                for _ in range(enemy.health):
+                    yield Action(x=enemy.x, shoot=True)