Initial commit

das_tetris_gui.py

@@ -0,0 +1,638 @@
+import os
+import sys
+os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
+import pygame
+import random
+from typing import List, Tuple
+import tetris_config as cfg
+
+# Initialize Pygame
+pygame.init()
+
+# ============================================================================
+# CONFIGURATION SECTION
+# ============================================================================
+
+cfg.load_config()
+BLOCK_TYPE = cfg.BLOCK_TYPE
+KEY_CONFIG = cfg.KEY_CONFIG
+CONTROLS_TEXT = cfg.CONTROLS_TEXT
+COLORS = cfg.COLORS
+STORE_WIDTH = cfg.STORE_WIDTH
+BLOCK_SIZE = cfg.BLOCK_SIZE
+
+# Be carefully with this method call due to it may rewrite current configuration
+# cfg.store_config()
+
+# ============================================================================
+# TETRIS GAME CLASS
+# ============================================================================
+
+class TetrisGame:
+    def __init__(self, width: int = STORE_WIDTH):
+        self.width = width
+        self.height = 20
+
+        self.score = 0
+        self.lines_cleared = 0
+        self.game_over = False
+        self.paused = False
+
+        # Game field: 0 = empty, 1-7 = block type
+        self.field = [[0 for _ in range(self.width)] for _ in range(self.height)]
+
+        # Current falling piece
+        self.current_block = None
+        self.current_block_x = 0
+        self.current_block_y = 0
+        self.current_block_rotation = 0
+
+        # Next piece preview
+        self.next_block = None
+        self.next_block_rotation = 0
+
+        # Timing
+        self.fall_time = 0
+        self.fall_speed = 0.5  # seconds
+        self.last_time = pygame.time.get_ticks()
+        self.key_pressed = {}  # Track which keys are pressed
+        self.key_cooldown = {}  # Cooldown timers for each key
+        self.key_cooldown_time = 100  # milliseconds
+        self.pause_key_pressed = False  # Track pause key state for toggle
+
+        # Initialize game
+        self.spawn_piece()
+
+    def get_block_min_score(self, block_type: cfg.BlockType) -> int:
+        """Get minimal score of block to be shown"""
+        return block_type.value['min_score']
+
+    def get_block_shapes(self, block_type: cfg.BlockType) -> List[List[List[int]]]:
+        """Get all rotation shapes for a block type"""
+        return block_type.value['shapes']
+
+    def get_block_color(self, block_type: cfg.BlockType) -> Tuple[int, int, int]:
+        """Get color for a block type"""
+        return block_type.value['color']
+
+    def spawn_piece(self):
+        """Spawn a new piece at the top"""
+        if self.next_block is None:
+            self.current_block = self.choice_random_block()
+            self.current_block_rotation = 0
+            self.next_block = self.choice_random_block()
+            self.next_block_rotation = 0
+        else:
+            self.current_block = self.next_block
+            self.current_block_rotation = self.next_block_rotation
+            while self.current_block == self.next_block:
+                self.next_block = self.choice_random_block()
+            self.next_block_rotation = 0
+
+        self.current_block_x = self.width // 2 - 2
+        self.current_block_y = 0
+
+        # Check if game is over (can't place new piece)
+        if not self.can_place_block(self.current_block_x, self.current_block_y,
+                                    self.current_block_rotation, self.current_block):
+            self.game_over = True
+
+    def choice_random_block(self) -> cfg.BlockType:
+        block: cfg.BlockType = random.choice(list(cfg.BlockType))
+        while self.get_block_min_score(block) > self.score:
+            block = random.choice(list(cfg.BlockType))
+        return block
+
+    def get_block_shape(self, block_type: cfg.BlockType, rotation: int) -> List[List[int]]:
+        """Get the shape matrix for a block at specific rotation"""
+        shapes = self.get_block_shapes(block_type)
+        return shapes[rotation % len(shapes)]
+
+    def can_place_block(self, x: int, y: int, rotation: int, block_type: cfg.BlockType) -> bool:
+        """Check if a block can be placed at given position"""
+        shape = self.get_block_shape(block_type, rotation)
+
+        for row_idx, row in enumerate(shape):
+            for col_idx, cell in enumerate(row):
+                if cell == 0:
+                    continue
+
+                field_x = x + col_idx
+                field_y = y + row_idx
+
+                # Check boundaries
+                if field_x < 0 or field_x >= self.width or field_y >= self.height:
+                    return False
+
+                # Check collisions
+                if field_y >= 0 and self.field[field_y][field_x] != 0:
+                    return False
+
+        return True
+
+    def place_block(self, x: int, y: int, rotation: int, block_type: cfg.BlockType, block_id: int):
+        """Place a block on the field"""
+        shape = self.get_block_shape(block_type, rotation)
+
+        for row_idx, row in enumerate(shape):
+            for col_idx, cell in enumerate(row):
+                if cell == 0:
+                    continue
+
+                field_x = x + col_idx
+                field_y = y + row_idx
+
+                if field_y >= 0 and 0 <= field_x < self.width:
+                    self.field[field_y][field_x] = block_id
+
+    def move_left(self):
+        """Move current block left"""
+        if self.can_place_block(self.current_block_x - 1, self.current_block_y,
+                                self.current_block_rotation, self.current_block):
+            self.current_block_x -= 1
+
+    def move_right(self):
+        """Move current block right"""
+        if self.can_place_block(self.current_block_x + 1, self.current_block_y,
+                                self.current_block_rotation, self.current_block):
+            self.current_block_x += 1
+
+    def rotate(self):
+        """Rotate current block"""
+        new_rotation = (self.current_block_rotation + 1) % len(
+            self.get_block_shapes(self.current_block))
+
+        if self.can_place_block(self.current_block_x, self.current_block_y,
+                                new_rotation, self.current_block):
+            self.current_block_rotation = new_rotation
+
+    def drop(self):
+        """Move block down, return True if block settled"""
+        if self.can_place_block(self.current_block_x, self.current_block_y + 1,
+                                self.current_block_rotation, self.current_block):
+            self.current_block_y += 1
+            return False
+        else:
+            # Block can't move down, place it
+            self.place_block(self.current_block_x, self.current_block_y,
+                             self.current_block_rotation, self.current_block,
+                             list(cfg.BlockType).index(self.current_block) + 1)
+
+            # Check for complete lines
+            self.clear_lines()
+
+            # Spawn new piece
+            self.spawn_piece()
+            return True
+
+    def clear_lines(self):
+        """Clear complete lines and return number cleared"""
+        # Build new field without complete lines
+        new_field = []
+        cleared_count = 0
+
+        # Check each row from bottom to top
+        for row_idx in range(self.height):
+            # If row is NOT complete, keep it
+            if not all(cell != 0 for cell in self.field[row_idx]):
+                new_field.append(self.field[row_idx][:])  # Copy the row
+            else:
+                cleared_count += 1
+
+        # Add empty rows at the top for each cleared line
+        for _ in range(cleared_count):
+            new_field.insert(0, [0] * self.width)
+
+        # Replace the field
+        self.field = new_field
+
+        # Update score and counter
+        if cleared_count > 0:
+            self.lines_cleared += cleared_count
+            # Bonus scoring: 1 line = 100, 2 lines = 300, 3 lines = 500, 4 lines = 800
+            score_bonus = [0, 100, 300, 500, 800]
+            self.score += score_bonus[min(cleared_count, 4)]
+
+        return cleared_count
+
+    def update(self, current_ticks: int):
+        """Update game state"""
+        elapsed = (current_ticks - self.last_time) / 1000.0  # Convert to seconds
+        self.last_time = current_ticks
+
+        if self.score > 5000:
+            self.fall_speed = 0.55
+        elif self.score > 10000:
+            self.fall_speed = 0.6
+        elif self.score > 15000:
+            self.fall_speed = 0.65
+
+        if not self.game_over and not self.paused:
+            self.fall_time += elapsed
+            if self.fall_time >= self.fall_speed:
+                self.fall_time = 0
+                self.drop()
+
+    def is_key_available(self, key: int, current_ticks: int) -> bool:
+        """Check if enough time has passed since last key press"""
+        if key not in self.key_cooldown:
+            self.key_cooldown[key] = 0
+
+        if current_ticks - self.key_cooldown[key] >= self.key_cooldown_time:
+            self.key_cooldown[key] = current_ticks
+            return True
+        return False
+
+    def handle_input(self, current_ticks: int, screen):
+        """Handle keyboard input"""
+        keys = pygame.key.get_pressed()
+
+        if keys[KEY_CONFIG['exit']]:
+            return not show_question_dialogue(screen, 'Are you sure to exit game?')
+
+        # Handle pause toggle (detect key press, not hold)
+        if keys[KEY_CONFIG['pause']]:
+            if not self.pause_key_pressed:
+                self.paused = not self.paused
+                self.pause_key_pressed = True
+        else:
+            self.pause_key_pressed = False
+
+        if keys[KEY_CONFIG['restart']]:
+            self.reset()
+            return True
+
+        if self.game_over or self.paused:
+            return True
+
+        # Prevent double key pressing with cooldown
+        if keys[KEY_CONFIG['left']] and self.is_key_available(KEY_CONFIG['left'], current_ticks):
+            self.move_left()
+
+        if keys[KEY_CONFIG['right']] and self.is_key_available(KEY_CONFIG['right'], current_ticks):
+            self.move_right()
+
+        if keys[KEY_CONFIG['rotate']] and self.is_key_available(KEY_CONFIG['rotate'], current_ticks):
+            self.rotate()
+
+        if keys[KEY_CONFIG['drop']] and self.is_key_available(KEY_CONFIG['drop'], current_ticks):
+            self.drop()
+
+        return True
+
+    def reset(self):
+        """Reset the game"""
+        self.score = 0
+        self.lines_cleared = 0
+        self.game_over = False
+        self.paused = False
+        self.field = [[0 for _ in range(self.width)] for _ in range(self.height)]
+        self.current_block = None
+        self.next_block = None
+        self.fall_time = 0
+        self.key_cooldown = {}
+        self.pause_key_pressed = False
+        self.spawn_piece()
+
+
+class TetrisRenderer:
+    def __init__(self, width: int = STORE_WIDTH):
+        self.width = width
+        self.height = 20
+        self.block_size = BLOCK_SIZE
+
+        # Calculate window size
+        self.field_width = self.width * self.block_size
+        self.field_height = self.height * self.block_size
+        self.ui_width = 250
+
+        self.window_width = self.field_width + self.ui_width + 60
+        self.window_height = self.field_height + 80
+
+        self.screen = pygame.display.set_mode((self.window_width, self.window_height))
+        pygame.display.set_caption("Tetris by -=:dAs:=-")
+
+        self.clock = pygame.time.Clock()
+        self.font_large = pygame.font.Font(None, 48)
+        self.font_medium = pygame.font.Font(None, 32)
+        self.font_small = pygame.font.Font(None, 24)
+
+        # Positioning
+        self.field_x = 20
+        self.field_y = 20
+        self.ui_x = self.field_x + self.field_width + 30
+        self.ui_y = self.field_y
+
+    def draw_block(self, x: int, y: int, color: Tuple[int, int, int], size: int = None):
+        """Draw a single block"""
+        if size is None:
+            size = self.block_size
+
+        pygame.draw.rect(self.screen, color, (x, y, size - 2, size - 2))
+        pygame.draw.rect(self.screen, (255, 255, 255), (x, y, size - 2, size - 2), 1)
+
+    def render(self, game: TetrisGame):
+        """Render the entire game"""
+        self.screen.fill(COLORS['background'])
+
+        # Draw field border
+        pygame.draw.rect(self.screen, COLORS['border'],
+                         (self.field_x - 2, self.field_y - 2,
+                          self.field_width + 4, self.field_height + 4), 2)
+
+        # Draw field background
+        pygame.draw.rect(self.screen, COLORS['field'],
+                         (self.field_x, self.field_y, self.field_width, self.field_height))
+
+        # Draw placed blocks
+        for row_idx, row in enumerate(game.field):
+            for col_idx, cell in enumerate(row):
+                if cell != 0:
+                    block_type = list(cfg.BlockType)[cell - 1]
+                    color = game.get_block_color(block_type)
+                    x = self.field_x + col_idx * self.block_size
+                    y = self.field_y + row_idx * self.block_size
+                    self.draw_block(x, y, color)
+
+        # Draw current falling piece
+        if game.current_block is not None:
+            shape = game.get_block_shape(game.current_block, game.current_block_rotation)
+            color = game.get_block_color(game.current_block)
+
+            for row_idx, row in enumerate(shape):
+                for col_idx, cell in enumerate(row):
+                    if cell == 1:
+                        x = self.field_x + (game.current_block_x + col_idx) * self.block_size
+                        y = self.field_y + (game.current_block_y + row_idx) * self.block_size
+
+                        if y >= self.field_y:  # Only draw if visible
+                            self.draw_block(x, y, color)
+
+        # Draw UI panel
+        self._draw_ui(game)
+
+        # Draw game over screen
+        if game.game_over:
+            self._draw_game_over()
+
+        # Draw pause screen
+        if game.paused:
+            self._draw_paused()
+
+        pygame.display.flip()
+
+    def _draw_ui(self, game: TetrisGame):
+        """Draw UI panel with score and next piece"""
+        # Title
+        title = self.font_medium.render("-=:dAs:=- TETRIS", True, COLORS['text'])
+        self.screen.blit(title, (self.ui_x, self.ui_y))
+
+        # Score
+        score_label = self.font_small.render("Score:", True, COLORS['text'])
+        score_value = self.font_medium.render(str(game.score), True, (255, 255, 0))
+        self.screen.blit(score_label, (self.ui_x, self.ui_y + 60))
+        self.screen.blit(score_value, (self.ui_x, self.ui_y + 90))
+
+        # Lines
+        lines_label = self.font_small.render("Lines:", True, COLORS['text'])
+        lines_value = self.font_medium.render(str(game.lines_cleared), True, (255, 255, 0))
+        self.screen.blit(lines_label, (self.ui_x, self.ui_y + 140))
+        self.screen.blit(lines_value, (self.ui_x, self.ui_y + 170))
+
+        # Next block
+        next_label = self.font_small.render("Next:", True, COLORS['text'])
+        self.screen.blit(next_label, (self.ui_x, self.ui_y + 220))
+
+        if game.next_block is not None:
+            shape = game.get_block_shape(game.next_block, game.next_block_rotation)
+            color = game.get_block_color(game.next_block)
+
+            preview_x = self.ui_x + 10
+            preview_y = self.ui_y + 260
+            block_preview_size = 15
+
+            for row_idx, row in enumerate(shape):
+                for col_idx, cell in enumerate(row):
+                    if cell == 1:
+                        x = preview_x + col_idx * block_preview_size
+                        y = preview_y + row_idx * block_preview_size
+                        self.draw_block(x, y, color, block_preview_size)
+
+        # Controls
+        controls_y = self.ui_y + 380
+
+        for i, text in enumerate(CONTROLS_TEXT):
+            if i == 0:
+                control_surf = self.font_small.render(text, True, (100, 200, 255))
+            else:
+                control_surf = self.font_small.render(text, True, (150, 150, 200))
+            self.screen.blit(control_surf, (self.ui_x - 5, controls_y + i * 25))
+
+    def _draw_game_over(self):
+        """Draw game over overlay"""
+        overlay = pygame.Surface((self.window_width, self.window_height))
+        overlay.set_alpha(128)
+        overlay.fill((0, 0, 0))
+        self.screen.blit(overlay, (0, 0))
+
+        game_over_text = self.font_large.render("GAME OVER", True, COLORS['game_over'])
+        restart_text = self.font_medium.render("Press R to Restart", True, COLORS['text'])
+
+        text_rect = game_over_text.get_rect(center=(self.window_width // 2, self.window_height // 2 - 40))
+        restart_rect = restart_text.get_rect(center=(self.window_width // 2, self.window_height // 2 + 40))
+
+        self.screen.blit(game_over_text, text_rect)
+        self.screen.blit(restart_text, restart_rect)
+
+    def _draw_paused(self):
+        """Draw pause overlay"""
+        overlay = pygame.Surface((self.window_width, self.window_height))
+        overlay.set_alpha(128)
+        overlay.fill((0, 0, 0))
+        self.screen.blit(overlay, (0, 0))
+
+        paused_text = self.font_large.render("PAUSED", True, (100, 200, 255))
+        continue_text = self.font_medium.render("Press P to Continue", True, COLORS['text'])
+
+        text_rect = paused_text.get_rect(center=(self.window_width // 2, self.window_height // 2 - 40))
+        continue_rect = continue_text.get_rect(center=(self.window_width // 2, self.window_height // 2 + 40))
+
+        self.screen.blit(paused_text, text_rect)
+        self.screen.blit(continue_text, continue_rect)
+
+    def get_fps(self) -> float:
+        """Get current FPS"""
+        return self.clock.get_fps()
+
+
+def show_question_dialogue(screen, question_text, font=None):
+    """
+    Shows a question dialogue with Yes and No buttons.
+
+    Args:
+        screen: Pygame display surface
+        question_text: The question to display
+        font: Pygame font object (optional, will create default if None)
+
+    Returns:
+        True if Yes is clicked, False if No is clicked
+    """
+    # Initialize font if not provided
+    if font is None:
+        font = pygame.font.Font(None, 36)
+
+    # Get screen dimensions
+    screen_width, screen_height = screen.get_size()
+
+    # Define colors
+    OVERLAY_COLOR = (0, 0, 0, 180)  # Semi-transparent black
+    DIALOG_BG = (50, 50, 50)
+    TEXT_COLOR = (255, 255, 255)
+    YES_COLOR = (50, 150, 50)
+    YES_HOVER = (70, 180, 70)
+    NO_COLOR = (150, 50, 50)
+    NO_HOVER = (180, 70, 70)
+    BUTTON_TEXT = (255, 255, 255)
+
+    # Create dialogue box dimensions
+    dialog_width = 500
+    dialog_height = 250
+    dialog_x = (screen_width - dialog_width) // 2
+    dialog_y = (screen_height - dialog_height) // 2
+
+    # Button dimensions
+    button_width = 120
+    button_height = 50
+    button_spacing = 40
+    yes_button_x = dialog_x + dialog_width // 2 - button_width - button_spacing // 2
+    no_button_x = dialog_x + dialog_width // 2 + button_spacing // 2
+    button_y = dialog_y + dialog_height - button_height - 30
+
+    yes_button_rect = pygame.Rect(yes_button_x, button_y, button_width, button_height)
+    no_button_rect = pygame.Rect(no_button_x, button_y, button_width, button_height)
+
+    # Render question text (word wrap)
+    words = question_text.split()
+    lines = []
+    current_line = []
+    max_width = dialog_width - 40
+
+    for word in words:
+        test_line = ' '.join(current_line + [word])
+        if font.size(test_line)[0] <= max_width:
+            current_line.append(word)
+        else:
+            if current_line:
+                lines.append(' '.join(current_line))
+            current_line = [word]
+    if current_line:
+        lines.append(' '.join(current_line))
+
+    # Main dialogue loop
+    running = True
+    result = None
+
+    while running:
+        mouse_pos = pygame.mouse.get_pos()
+        yes_hovered = yes_button_rect.collidepoint(mouse_pos)
+        no_hovered = no_button_rect.collidepoint(mouse_pos)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                if event.button == 1:  # Left click
+                    if yes_hovered:
+                        result = True
+                        running = False
+                    elif no_hovered:
+                        result = False
+                        running = False
+
+            # Optional: keyboard shortcuts
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_y:
+                    result = True
+                    running = False
+                elif event.key == pygame.K_n:
+                    result = False
+                    running = False
+
+        # Draw everything
+        # Create semi-transparent overlay
+        overlay = pygame.Surface((screen_width, screen_height))
+        overlay.set_alpha(180)
+        overlay.fill((0, 0, 0))
+        screen.blit(overlay, (0, 0))
+
+        # Draw dialogue box
+        pygame.draw.rect(screen, DIALOG_BG, (dialog_x, dialog_y, dialog_width, dialog_height))
+        pygame.draw.rect(screen, TEXT_COLOR, (dialog_x, dialog_y, dialog_width, dialog_height), 2)
+
+        # Draw question text
+        text_y = dialog_y + 30
+        for line in lines:
+            text_surface = font.render(line, True, TEXT_COLOR)
+            text_rect = text_surface.get_rect(center=(dialog_x + dialog_width // 2, text_y))
+            screen.blit(text_surface, text_rect)
+            text_y += font.get_height() + 5
+
+        # Draw Yes button
+        yes_color = YES_HOVER if yes_hovered else YES_COLOR
+        pygame.draw.rect(screen, yes_color, yes_button_rect, border_radius=5)
+        pygame.draw.rect(screen, TEXT_COLOR, yes_button_rect, 2, border_radius=5)
+        yes_text = font.render("Yes", True, BUTTON_TEXT)
+        yes_text_rect = yes_text.get_rect(center=yes_button_rect.center)
+        screen.blit(yes_text, yes_text_rect)
+
+        # Draw No button
+        no_color = NO_HOVER if no_hovered else NO_COLOR
+        pygame.draw.rect(screen, no_color, no_button_rect, border_radius=5)
+        pygame.draw.rect(screen, TEXT_COLOR, no_button_rect, 2, border_radius=5)
+        no_text = font.render("No", True, BUTTON_TEXT)
+        no_text_rect = no_text.get_rect(center=no_button_rect.center)
+        screen.blit(no_text, no_text_rect)
+
+        pygame.display.flip()
+
+    return result
+
+
+def main():
+    """Main game loop"""
+    game = TetrisGame(width=STORE_WIDTH)
+    renderer = TetrisRenderer(width=STORE_WIDTH)
+
+    running = True
+
+    while running:
+        current_ticks = pygame.time.get_ticks()
+
+        # Handle events
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT and show_question_dialogue(renderer.screen, 'Are you sure to exit game?'):
+                running = False
+                break
+
+        if not running:
+            break  # Exit main loop if quit was requested
+
+        # Handle input
+        if not game.handle_input(current_ticks, renderer.screen):
+            running = False
+            continue
+
+        # Update game
+        game.update(current_ticks)
+
+        # Render
+        renderer.render(game)
+        renderer.clock.tick(60)  # 60 FPS
+
+    pygame.quit()
+
+
+if __name__ == "__main__":
+    main()