mice/engine/sdl2.py

import os
import sdl2
import sdl2.ext
import sdl2.sdlmixer
from sdl2.ext.compat import byteify
from PIL import Image

class GameWindow:
    def __init__(self, width, height, cell_size, title="Default", key_callback=None):
        os.environ["SDL_VIDEODRIVER"] = "x11" 
        self.cell_size = cell_size
        self.width = width * cell_size
        self.height = height * cell_size
        self.actual_screen_size = (640, 480)  
        if self.width > self.actual_screen_size[0] or self.height > self.actual_screen_size[1]:
            self.target_size = self.actual_screen_size
        else:
            self.target_size = (self.width, self.height)
        self.w_start_offset = (self.target_size[0] - self.width) // 2
        self.h_start_offset = (self.target_size[1] - self.height) // 2
        self.w_offset = self.w_start_offset
        self.h_offset = self.h_start_offset
        self.max_w_offset = self.target_size[0] - self.width
        self.max_h_offset = self.target_size[1] - self.height
        print(f"Screen size: {self.width}x{self.height}")
        self.window = sdl2.ext.Window(title=title, size=self.target_size,)# flags=sdl2.SDL_WINDOW_FULLSCREEN)
        self.delay = 30
        sdl2.ext.init(joystick=True, audio=True)
        self.load_joystick()
        sdl2.SDL_Init(sdl2.SDL_INIT_AUDIO)
        sdl2.sdlmixer.Mix_OpenAudio(44100, sdl2.sdlmixer.MIX_DEFAULT_FORMAT, 2, 2048)
        self.window.show()
        self.renderer = sdl2.ext.Renderer(self.window, flags=sdl2.SDL_RENDERER_ACCELERATED)
        self.factory = sdl2.ext.SpriteFactory(renderer=self.renderer)
        self.fonts = self.generate_fonts("assets/decterm.ttf")
        self.running = True
        self.key_callback = key_callback
        self.performance = 0

    def load_joystick(self):
        sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK)
        sdl2.SDL_JoystickOpen(0)
        
    def generate_fonts(self,font_file):
        fonts = {}
        for i in range(10, 70, 1):
            fonts.update({i: sdl2.ext.FontManager(font_path=font_file, size=i)})
        return fonts
    
    def load_image(self, path, transparent_color=None):
        image_path = os.path.join(os.path.dirname(__file__), "..", "assets", path)
        image = Image.open(image_path)
        if transparent_color:
            image = image.convert("RGBA")
            datas = image.getdata()
            new_data = []
            for item in datas:
                if item[:3] == transparent_color:
                    new_data.append((255, 255, 255, 0))
                else:
                    new_data.append(item)
            image.putdata(new_data)
        scale = self.cell_size // 20
        image = image.resize((image.width * scale, image.height * scale), Image.NEAREST)
        return self.factory.from_surface(sdl2.ext.pillow_to_surface(image))
    
    def draw_text(self, text, font, position, color):
        sprite = self.factory.from_text(text, color=color, fontmanager=font)
        if position == "center":
            sprite.position = (self.size[0] // 2 - sprite.size[0] // 2, self.size[1] // 2 - sprite.size[1] // 2)
        else:
            sprite.position = position
        self.renderer.copy(sprite, dstrect=sprite.position)

    def draw_image(self, x, y, sprite, tag, anchor="nw"):
        sprite.position = (x+self.w_offset, y+self.h_offset)
        self.renderer.copy(sprite, dstrect=sprite.position)
        
    def draw_rectangle(self, x, y, width, height, tag, outline="red", filling=None):
        x, y = x + self.w_offset, y + self.h_offset
        if filling:
            self.renderer.fill((x, y, width, height), sdl2.ext.Color(*filling))
        else:
            self.renderer.draw_rect((x, y, width, height), sdl2.ext.Color(*outline))
        
    def draw_pointer(self, x, y):
        x=x+self.w_offset
        y=y+self.h_offset
        for i in range(3):
            self.renderer.draw_rect((x + i,y+i, self.cell_size-2*i, self.cell_size-2*i), color=sdl2.ext.Color(255, 0, 0))
        
    def delete_tag(self, tag):
        pass
    
    def get_image_size(self, image):
        return image.size
    
    def update_status(self, text):
        fps = int(1000 / self.performance) if self.performance != 0 else 0
        text = f"FPS: {fps} - {text}"
        font = self.fonts[20]
        sprite = self.factory.from_text(text, color=sdl2.ext.Color(0, 0, 0), fontmanager=font)
        text_width, text_height = sprite.size
        self.renderer.fill((3, 3, text_width + 10, text_height + 4), sdl2.ext.Color(255, 255, 255))
        self.draw_text(text, font, (8, 5), sdl2.ext.Color(0, 0, 0))
        
    def new_cycle(self, delay, callback):
        pass
    
    def full_screen(self,flag):
        sdl2.SDL_SetWindowFullscreen(self.window.window, flag)
        
    def mainloop(self, **kwargs):
        while self.running:
            performance_start = sdl2.SDL_GetPerformanceCounter()
            self.renderer.clear()
            if "bg_update" in kwargs:
                kwargs["bg_update"]()
            kwargs["update"]()
            events = sdl2.ext.get_events()
            for event in events:
                if event.type == sdl2.SDL_QUIT:
                    self.running = False
                elif event.type == sdl2.SDL_KEYDOWN and self.key_callback:
                    key = sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf-8')
                    self.key_callback(key)
                elif event.type == sdl2.SDL_KEYUP and self.key_callback:
                    key = sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf-8') + "Release"
                    self.key_callback(key)
                elif event.type == sdl2.SDL_MOUSEMOTION:
                    self.key_callback("mouse", coords=(event.motion.x, event.motion.y))
                elif event.type == sdl2.SDL_JOYBUTTONDOWN:
                    key = event.jbutton.button
                    self.key_callback(key)
                    
            # Disegna qui gli sprite
            self.renderer.present()
            self.performance = (sdl2.SDL_GetPerformanceCounter() - performance_start) / sdl2.SDL_GetPerformanceFrequency() * 1000
            if self.performance < self.delay:
                delay = self.delay - round(self.performance)
            sdl2.SDL_Delay(delay)
            
    def close(self):
        self.running = False
        sdl2.ext.quit()

    def scroll_view(self, pointer):
        """
        Adjusts the view offset based on the given pointer coordinates.
        Scales them down by half, then adjusts offsets, ensuring they don't
        exceed maximum allowed values.
        """
        x, y = pointer
        
        # Scale down and invert
        x = -(x // 2) * self.cell_size
        y = -(y // 2) * self.cell_size
        
        # Clamp horizontal offset
        if x <= self.max_w_offset + self.cell_size:
            x = self.max_w_offset
        

        # Clamp vertical offset
        if y < self.max_h_offset:
            y = self.max_h_offset

        self.w_offset = x
        self.h_offset = y
        
    def play_sound(self, sound_file):
        sample = sdl2.sdlmixer.Mix_LoadWAV(byteify(sound_file, "utf-8"))
        if sample is None:
            raise RuntimeError("Cannot open audio file: {}".format(sdl2.sdlmixer.Mix_GetError()))
        channel = sdl2.sdlmixer.Mix_PlayChannel(-1, sample, 0)
        if channel == -1:
            print(f"Cannot play sound: {sdl2.sdlmixer.Mix_GetError()}")