WarioWare-Black-and-WAH/microgames/wario/hot_or_cold.py

# microgames/wario/hot_or_cold.py
import pygame
import random
from engine.scene import Scene
from settings import *
from engine.utils import scale_to_fit

class HotOrCold(Scene):

    def __init__(self, manager):
        super().__init__(manager)
        self.prompt = "Hot or cold?"
        self.character_state = None
        self.character_rect = pygame.Rect(0, 0, 100, 200) # Initial placeholder size
        self.items = []
        self.dragging_item = None
        self.timer = 4.0 / self.manager.speed
        self.state = "playing"
        self.end_timer = 2.0

        self.character_images_raw = {}
        self.item_images_raw = {}

        # Load raw images and get their original sizes
        try:
            # Character images
            self.character_images_raw["cold"] = pygame.image.load(resource_path("Assets/images/wario/shivering_char.png")).convert_alpha()
            self.character_images_raw["hot"] = pygame.image.load(resource_path("Assets/images/wario/sweating_char.png")).convert_alpha()
            # Determine character display size based on screen height
            char_height = SCREEN_HEIGHT * 0.3
            self.character_display_rect = pygame.Rect(0, 0, 100, char_height) # Height-driven scaling, added placeholder width

            # Item images
            item_paths = {
                "blanket": resource_path("Assets/images/wario/blanket.png"),
                "fan": resource_path("Assets/images/wario/fan.png"),
                "book": resource_path("Assets/images/wario/book.png"),
                "plant": resource_path("Assets/images/wario/plant.png")
            }
            self.item_display_rects = {}
            item_height = SCREEN_HEIGHT * 0.15
            for name, path in item_paths.items():
                self.item_images_raw[name] = pygame.image.load(path).convert_alpha()
                self.item_display_rects[name] = pygame.Rect(0, 0, 100, item_height) # Height-driven scaling, added placeholder width

        except (pygame.error, FileNotFoundError) as e:
            print(f"Error loading images for HotOrCold: {e}")
            self.character_images_raw = {}
            self.item_images_raw = {}

    def start(self):
        self.timer = 4.0 / self.manager.speed
        self.state = "playing"
        self.end_timer = 2.0
        self.character_state = random.choice(["hot", "cold"])
        
        # Position character based on its display rect
        if self.character_images_raw:
            # Scale to fit the display rect to get actual dimensions
            scaled_img, scaled_rect = scale_to_fit(self.character_images_raw[self.character_state], self.character_display_rect)
            self.character_rect = scaled_rect
            self.character_rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
        else:
            self.character_rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)

        self.dragging_item = None
        
        self.items = []
        item_names = ["blanket", "fan", "book", "plant"]
        random.shuffle(item_names)

        for i, name in enumerate(item_names):
            item_rect = pygame.Rect(0, 0, 0, 0) # Placeholder
            if name in self.item_images_raw:
                scaled_img, scaled_rect = scale_to_fit(self.item_images_raw[name], self.item_display_rects[name])
                item_rect = scaled_rect
            else:
                item_rect = pygame.Rect(0, 0, 100, 100) # Fallback size

            x = (SCREEN_WIDTH // (len(item_names) + 1)) * (i + 1)
            item_rect.midbottom = (x, SCREEN_HEIGHT - 20)
            self.items.append({"name": name, "rect": item_rect, "color": BLACK})

    def update(self, dt, time_left=None):
        if self.state == "playing":
            if time_left is not None and time_left <= 0:
                self.end(False) # Failure due to timeout

            mouse_pos = pygame.mouse.get_pos()
            mouse_pressed = pygame.mouse.get_pressed()

            if mouse_pressed[0]:
                if self.dragging_item is None:
                    for item in self.items:
                        if item["rect"].collidepoint(mouse_pos):
                            self.dragging_item = item
            else:
                if self.dragging_item is not None:
                    if self.character_rect.colliderect(self.dragging_item["rect"]):
                        if self.character_state == "cold" and self.dragging_item["name"] == "blanket":
                            self.end(True)
                        elif self.character_state == "hot" and self.dragging_item["name"] == "fan":
                            self.end(True)
                        else:
                            self.end(False)
                    self.dragging_item = None
            
            if self.dragging_item is not None:
                self.dragging_item["rect"].center = mouse_pos

        elif self.state == "success" or self.state == "failure":
            self.end_timer -= dt
            if self.end_timer <= 0:
                self.manager.microgame_finished(self.state == "success", 'wario')

    def draw(self, screen):
        screen.fill(WARIO_BG_COLOR)

        if self.state == "playing":
            # Draw character
            char_image_raw = self.character_images_raw.get(self.character_state)
            if char_image_raw:
                scaled_img, scaled_rect = scale_to_fit(char_image_raw, self.character_rect)
                screen.blit(scaled_img, scaled_rect)
            else:
                color = BLUE if self.character_state == "cold" else RED
                pygame.draw.rect(screen, color, self.character_rect)

            # Draw items
            for item in self.items:
                item_image_raw = self.item_images_raw.get(item["name"])
                if item_image_raw:
                    scaled_img, scaled_rect = scale_to_fit(item_image_raw, item["rect"])
                    screen.blit(scaled_img, scaled_rect)
                else:
                    pygame.draw.rect(screen, item["color"], item["rect"])

            # Timer is now drawn by GameManager
        # Removed old success/failure drawing logic

    def end(self, success):
        if success:
            self.state = "success"
        else:
            self.state = "failure"