Arcade-re váltás

mkenv.sh

@@ -1,2 +1,2 @@
 python -m venv venv
-./venv/bin/pip install pygame
+./venv/bin/pip install arcade 

mkvenv.bat

@@ -1,2 +1,2 @@
 python -m venv venv
-.\venv\Scripts\pip install pygame
+.\venv\Scripts\pip install arcade 

src/assets.py

@@ -1,12 +1,8 @@
-import pygame
+import arcade
+
 sprites = {
-	"louisu": pygame.image.load("res/sprite/louisu.png"),
-	"louisd": pygame.image.load("res/sprite/louisd.png"),
-	"louisl": pygame.image.load("res/sprite/louisl.png"),
-	"louisb": pygame.image.load("res/sprite/louisb.png"),
+    "louisu": arcade.load_texture("res/sprite/louisu.png"),
+    "louisd": arcade.load_texture("res/sprite/louisd.png"),
+    "louisl": arcade.load_texture("res/sprite/louisl.png"),
+    "louisb": arcade.load_texture("res/sprite/louisb.png"),
 }
-
-
-def convert():
-	for name, image in sprites.items():
-		sprites[name] = image.convert_alpha()

src/gamestate.py

@@ -15,5 +15,5 @@ def switch_gamestate(state):
 def update(dt):
     gamestates[gamestate].update(dt)
 
-def draw(screen):
-    gamestates[gamestate].draw(screen)
+def draw(game):
+    gamestates[gamestate].draw(game)

src/gamestates/none.py

@@ -6,6 +6,6 @@ def switch():
 def update(dt):
     gamestate.switch_gamestate("title")
 
-def draw(screen):
+def draw():
     pass
 

src/gamestates/title.py

@@ -1,3 +1,4 @@
+import arcade 
 import assets
 
 def switch():
@@ -6,7 +7,19 @@ def switch():
 def update(dt):
     pass
 
-def draw(screen):
-    screen.fill("blue")
-    screen.blit(assets.sprites["louisu"], (0, 0))
+def draw(game):
+    arcade.draw_rect_filled(
+        arcade.LBWH(0, 0, game.screen_width, game.screen_height),
+        arcade.color.BLUE,
+    )
 
+    arcade.draw_texture_rect(
+        assets.sprites["louisu"],
+        arcade.LBWH(
+            0,
+            0,
+            assets.sprites["louisu"].width,
+            assets.sprites["louisu"].height
+        ),
+        pixelated=True
+    )

src/main.py

@@ -1,53 +1,126 @@
-import pygame
+import arcade
 import assets
 import gamestate
 
-pygame.init()
+SCREEN_WIDTH = 256
+SCREEN_HEIGHT = 224
 
-GAME_WIDTH = 256
-GAME_HEIGHT = 224
+class TextureRenderer:
+    def __init__(self, ctx):
+        self.ctx = ctx
 
-screen = pygame.display.set_mode((GAME_WIDTH, GAME_HEIGHT), pygame.RESIZABLE)
-pygame.display.set_caption("Rick Roll To The Moon")
-clock = pygame.time.Clock()
-running = True
-dt = 0
+        self.program = ctx.program(
+            vertex_shader="""
+                #version 330
 
-game_screen = pygame.Surface((GAME_WIDTH, GAME_HEIGHT))
+                in vec2 in_vert;
+                in vec2 in_uv;
 
-assets.convert()
+                out vec2 uv;
 
-while running:
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            running = False
+                uniform vec2 screen_size;
+                uniform vec4 bounds;
 
-    gamestate.update(dt)
-    gamestate.draw(game_screen)
+                void main() {
+                    // Convert quad coordinates from [-1, 1] to [0, 1]
+                    vec2 local = in_vert * 0.5 + 0.5;
+                    
+                    // bounds = x, y, width, height in pixels
+                    vec2 pixel_pos = bounds.xy + local * bounds.zw;
 
-    screen.fill((0, 0, 0))
-    
-    scale = min(
-        screen.get_width() // GAME_WIDTH,
-        screen.get_height() // GAME_HEIGHT
-    )
-    scale = max(1, scale)
+                    // Convert pixels to NDC
+                    vec2 ndc = pixel_pos / screen_size * 2.0 - 1.0;
 
-    scaled_width = GAME_WIDTH * scale
-    scaled_height = GAME_HEIGHT * scale
+                    gl_Position = vec4(ndc, 0.0, 1.0);
+                    uv = in_uv;
+                }
+            """,
+            fragment_shader="""
+                #version 330
 
-    x = (screen.get_width() - scaled_width) // 2
-    y = (screen.get_height() - scaled_height) // 2
+                uniform sampler2D tex;
 
-    scaled_surface = pygame.transform.scale(
-        game_screen,
-        (scaled_width, scaled_height)
-    )
+                in vec2 uv;
+                out vec4 color;
 
-    screen.blit(scaled_surface, (x, y))
-    
-    pygame.display.flip()
+                void main() {
+                    color = texture(tex, uv);
+                }
+            """,
+        )
 
-    dt = clock.tick(60) / 1000
+        self.quad = arcade.gl.geometry.quad_2d()
 
-pygame.quit()
+    def render(self, texture, x, y, width, height):
+        self.program["screen_size"] = (self.ctx.screen.width,
+                                       self.ctx.screen.height)
+        self.program["bounds"] = (x, y, width, height)
+
+        texture.use(0)
+        self.program["tex"] = 0
+
+        self.quad.render(self.program)
+
+class Game(arcade.Window):
+    def __init__(self):
+        super().__init__(
+            SCREEN_WIDTH,
+            SCREEN_HEIGHT,
+            "Rick Roll To The Moon",
+            resizable=True,
+        )
+
+        self.screen_width = SCREEN_WIDTH
+        self.screen_height = SCREEN_HEIGHT
+
+        self.game_texture = self.ctx.texture(
+            (SCREEN_WIDTH, SCREEN_HEIGHT),
+            components=4,
+        )
+        self.game_texture.filter = (self.ctx.NEAREST, self.ctx.NEAREST)
+
+        self.framebuffer = self.ctx.framebuffer(
+            color_attachments=[self.game_texture],
+        )
+        
+        self.renderer = TextureRenderer(self.ctx)
+
+    def on_update(self, dt):
+        gamestate.update(dt)
+
+    def on_draw(self):
+        self.framebuffer.use()
+        self.framebuffer.clear()
+        self.ctx.viewport = (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
+        
+        gamestate.draw(self)
+        
+        self.use()
+        self.clear()
+        self.ctx.viewport = (0, 0, self.width, self.height)
+
+        scale = max(
+            1,
+            min(
+                self.width // SCREEN_WIDTH,
+                self.height // SCREEN_HEIGHT,
+            ),
+        )
+
+        scaled_width = SCREEN_WIDTH * scale
+        scaled_height = SCREEN_HEIGHT * scale
+
+        x = (self.width - scaled_width) // 2
+        y = (self.height - scaled_height) // 2
+
+        self.renderer.render(
+            self.game_texture,
+            x,
+            y,
+            scaled_width,
+            scaled_height,
+        )
+
+
+game = Game()
+arcade.run()