import os import random import sdl2 import sdl2.ext from sdl2.ext.compat import byteify from ctypes import * import ctypes from PIL import Image from sdl2 import SDL_AudioSpec class GameWindow: def __init__(self, width, height, cell_size, title="Default", key_callback=None): self.cell_size = cell_size self.width = width * cell_size self.height = height * cell_size actual_screen_size = os.environ.get("RESOLUTION", "640x480").split("x") actual_screen_size = tuple(map(int, actual_screen_size)) self.target_size = actual_screen_size if self.width > actual_screen_size[0] or self.height > actual_screen_size[1] else (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 self.scale = self.target_size[1] // self.cell_size print(f"Screen size: {self.width}x{self.height}") sdl2.ext.init(joystick=True) sdl2.SDL_Init(sdl2.SDL_INIT_AUDIO) self.window = sdl2.ext.Window(title=title, size=self.target_size,)# flags=sdl2.SDL_WINDOW_FULLSCREEN) self.delay = 30 self.load_joystick() 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.dialog("Loading assets...") self.renderer.present() self.running = True self.key_down, self.key_up, self.axis_scroll = key_callback self.performance = 0 self.audio_devs = {} self.button_cursor = [0, 0] self.buttons = {} self.audio_devs["base"] = sdl2.SDL_OpenAudioDevice(None, 0, SDL_AudioSpec(freq=22050, aformat=sdl2.AUDIO_U8, channels=1, samples=2048), None, 0) self.audio_devs["effects"] = sdl2.SDL_OpenAudioDevice(None, 0, SDL_AudioSpec(freq=22050, aformat=sdl2.AUDIO_U8, channels=1, samples=2048), None, 0) self.audio_devs["music"] = sdl2.SDL_OpenAudioDevice(None, 0, SDL_AudioSpec(freq=22050, aformat=sdl2.AUDIO_U8, channels=1, samples=2048), None, 0) def create_texture(self, tiles: list): # Always create a fresh surface since we free it after use bg_surface = sdl2.SDL_CreateRGBSurface(0, self.width, self.height, 32, 0, 0, 0, 0) for tile in tiles: dstrect = sdl2.SDL_Rect(tile[1], tile[2], self.cell_size, self.cell_size) sdl2.SDL_BlitSurface(tile[0], None, bg_surface, dstrect) bg_texture = self.factory.from_surface(bg_surface) sdl2.SDL_FreeSurface(bg_surface) return bg_texture 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, surface=False): image_path = os.path.join("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 if surface: return sdl2.ext.pillow_to_surface(image.resize((image.width * scale, image.height * scale), Image.NEAREST)) 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": position = ("center", "center") if position[0] == "center": position = (self.target_size[0] // 2 - sprite.size[0] // 2, position[1]) if position[1] == "center": position = (position[0], self.target_size[1] // 2 - sprite.size[1] // 2) sprite.position = position #print(sprite.position) self.renderer.copy(sprite, dstrect=sprite.position) def draw_background(self, bg_texture): self.renderer.copy(bg_texture, dstrect=sdl2.SDL_Rect(self.w_offset, self.h_offset, self.width, self.height)) def draw_image(self, x, y, sprite, tag, anchor="nw"): if not self.is_in_visible_area(x, y): return 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): 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 dialog(self, text, **kwargs): self.draw_rectangle(50, 50, self.target_size[0] - 100, self.target_size[1] - 100, "win", filling=(255, 255, 255)) self.draw_text(text, self.fonts[self.target_size[1]//20], "center", sdl2.ext.Color(0, 0, 0)) if subtitle := kwargs.get("subtitle"): self.draw_text(subtitle, self.fonts[self.target_size[1]//30], ("center", self.target_size[1] // 2 + 50), sdl2.ext.Color(0, 0, 0)) if image := kwargs.get("image"): image_size = self.get_image_size(image) self.draw_image(self.target_size[0] // 2 - image_size[0] // 2 - self.w_offset, self.target_size[1] // 2 - image_size[1] * 2 - self.h_offset, image, "win") if scores := kwargs.get("scores"): #self.draw_text("Scores:", self.fonts[self.target_size[1]//20], (self.target_size[0] // 2 - 50, self.target_size[1] // 2 + 50), sdl2.ext.Color(0, 0, 0)) sprite = self.factory.from_text("Scores:", color=sdl2.ext.Color(0, 0, 0), fontmanager=self.fonts[self.target_size[1]//20]) sprite.position = (self.target_size[0] // 2 - 50, self.target_size[1] // 2 + 30) self.renderer.copy(sprite, dstrect=sprite.position) for i, score in enumerate(scores[:5]): score = " - ".join(score) self.draw_text(score, self.fonts[self.target_size[1]//40], ("center", self.target_size[1] // 2 + 50 + 30 * (i + 1)), sdl2.ext.Color(0, 0, 0)) 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 is_in_visible_area(self, x, y): return -self.w_offset -self.cell_size <= x <= self.width - self.w_offset and -self.h_offset -self.cell_size <= y <= self.height - self.h_offset def get_perf_counter(self): return sdl2.SDL_GetPerformanceCounter() 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_down: key = sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf-8') self.key_down(key) elif event.type == sdl2.SDL_KEYUP and self.key_down: key = sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf-8') self.key_up(key) print(key) elif event.type == sdl2.SDL_MOUSEMOTION: self.key_down("mouse", coords=(event.motion.x, event.motion.y)) elif event.type == sdl2.SDL_JOYBUTTONDOWN: key = event.jbutton.button self.key_down(key) elif event.type == sdl2.SDL_JOYBUTTONUP: key = event.jbutton.button self.key_up(key) # elif event.type == sdl2.SDL_JOYAXISMOTION: # self.axis_scroll(event.jaxis.axis, event.jaxis.value) # Disegna qui gli sprite #rect = sdl2.SDL_Rect(self.w_offset, self.h_offset, self.target_size[0], self.target_size[1]) #sdl2.SDL_RenderSetClipRect(self.renderer.sdlrenderer, rect) 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) else: delay = 0 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, tag="base"): sound_file = os.path.join("sound", sound_file) rw = sdl2.SDL_RWFromFile(byteify(sound_file, "utf-8"), b"rb") if not rw: raise RuntimeError("Failed to open sound file") _buf = POINTER(sdl2.Uint8)() _length = sdl2.Uint32() spec = SDL_AudioSpec(freq=22050, aformat=sdl2.AUDIO_U8, channels=1, samples=2048) if sdl2.SDL_LoadWAV_RW(rw, 1, byref(spec), byref(_buf), byref(_length)) == None: raise RuntimeError("Failed to load WAV") devid = self.audio_devs[tag] # Clear any queued audio sdl2.SDL_ClearQueuedAudio(devid) # Start playing audio sdl2.SDL_QueueAudio(devid, _buf, _length) sdl2.SDL_PauseAudioDevice(devid, 0) def stop_sound(self): for dev in self.audio_devs: if not dev[0]: sdl2.SDL_PauseAudioDevice(dev[1], 1) sdl2.SDL_ClearQueuedAudio(dev[1]) def start_dialog(self, **kwargs): self.dialog("Welcome to the Mice!", subtitle="A game by Matteo because was bored", **kwargs) center = self.get_view_center() #self.draw_button(center[0], center[1] + 10 * self.scale, "Start", 120, 50, (0, 0)) def draw_button(self, x, y, text, width, height, coords): if self.button_cursor[0] == coords[0] and self.button_cursor[1] == coords[1]: color = (0, 0, 255) self.draw_rectangle(x, y, width, height, "button", outline8u=color) self.draw_text(text, self.fonts[20], (x + 10, y + 10), (0,0,0)) def get_view_center(self): return self.w_offset + self.width // 2, self.h_offset + self.height // 2 def generate_blood_surface(self): """Genera dinamicamente una superficie di macchia di sangue usando SDL2""" size = self.cell_size # Crea una superficie RGBA per la macchia di sangue blood_surface = sdl2.SDL_CreateRGBSurface( 0, size, size, 32, 0x000000FF, # R mask 0x0000FF00, # G mask 0x00FF0000, # B mask 0xFF000000 # A mask ) if not blood_surface: return None # Blocca la superficie per il disegno pixel per pixel sdl2.SDL_LockSurface(blood_surface) # Ottieni i dati dei pixel pixels = cast(blood_surface.contents.pixels, POINTER(c_uint32)) pitch = blood_surface.contents.pitch // 4 # pitch in pixel (32-bit) # Colori del sangue (variazioni di rosso) blood_colors = [ 0xFF8B0000, # Rosso scuro 0xFFB22222, # Rosso mattone 0xFFDC143C, # Cremisi 0xFFFF0000, # Rosso puro 0xFF800000, # Marrone ] # Genera la macchia con un algoritmo di diffusione center_x, center_y = size // 2, size // 2 # Inizia dal centro e espandi verso l'esterno max_radius = size // 3 + random.randint(-3, 5) for y in range(size): for x in range(size): # Calcola la distanza dal centro distance = ((x - center_x) ** 2 + (y - center_y) ** 2) ** 0.5 # Probabilità di avere sangue basata sulla distanza if distance <= max_radius: # Più vicino al centro, più probabile avere sangue probability = max(0, 1 - (distance / max_radius)) # Aggiungi rumore per forma irregolare noise = random.random() * 0.7 if random.random() < probability * noise: # Scegli un colore di sangue casuale color = random.choice(blood_colors) # Aggiungi variazione di alpha per trasparenza alpha = int(255 * probability * random.uniform(0.6, 1.0)) color = (color & 0x00FFFFFF) | (alpha << 24) pixels[y * pitch + x] = color else: # Pixel trasparente pixels[y * pitch + x] = 0x00000000 else: # Fuori dal raggio, trasparente pixels[y * pitch + x] = 0x00000000 # Aggiungi alcune gocce sparse intorno alla macchia principale for _ in range(random.randint(3, 8)): drop_x = center_x + random.randint(-max_radius - 5, max_radius + 5) drop_y = center_y + random.randint(-max_radius - 5, max_radius + 5) if 0 <= drop_x < size and 0 <= drop_y < size: drop_size = random.randint(1, 3) for dy in range(-drop_size, drop_size + 1): for dx in range(-drop_size, drop_size + 1): nx, ny = drop_x + dx, drop_y + dy if 0 <= nx < size and 0 <= ny < size: if random.random() < 0.6: color = random.choice(blood_colors[:3]) # Colori più scuri per le gocce alpha = random.randint(100, 200) color = (color & 0x00FFFFFF) | (alpha << 24) pixels[ny * pitch + nx] = color # Sblocca la superficie sdl2.SDL_UnlockSurface(blood_surface) # Converte la superficie in una texture usando il factory del gioco return blood_surface def draw_blood_surface(self, blood_surface, position): # Create a new surface for the blood texture since bg_surface may have been freed temp_surface = sdl2.SDL_CreateRGBSurface(0, self.cell_size, self.cell_size, 32, 0, 0, 0, 0) if temp_surface is None: sdl2.SDL_FreeSurface(blood_surface) return None # Copy the blood surface to the temporary surface sdl2.SDL_BlitSurface(blood_surface, None, temp_surface, None) sdl2.SDL_FreeSurface(blood_surface) # Create texture from the temporary surface texture = self.factory.from_surface(temp_surface) sdl2.SDL_FreeSurface(temp_surface) return texture