VertexEngine 1.2rc4__4-py3-none-any.whl

VertexEngine/engine.py

@@ -0,0 +1,70 @@
+from PyQt6.QtWidgets import QWidget
+from PyQt6.QtGui import QImage, QPainter
+from PyQt6.QtCore import QTimer, Qt
+import pygame
+from .scenes import SceneManager
+pygame.init()
+
+class GameEngine(QWidget):
+    def __init__(self, width=800, height=600, fps=60):
+        super().__init__()
+        self.width = width
+        self.height = height
+        self.fps = fps
+
+        # Qt key tracking
+        self.keys_down = set()
+
+        # pygame surface
+        self.screen = pygame.Surface((self.width, self.height))
+
+        # Scene manager
+        self.scene_manager = SceneManager()
+
+        # Timer
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.update_frame)
+        self.timer.start(1000 // self.fps)
+
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+
+    # ---------------------- RENDER ----------------------
+
+    def paintEvent(self, event):
+        self.screen.fill((50, 50, 100))
+
+        self.scene_manager.draw(self.screen)
+
+        raw = pygame.image.tostring(self.screen, "RGBA")
+        img = QImage(
+            raw,
+            self.width,
+            self.height,
+            QImage.Format.Format_RGBA8888
+        )
+
+        painter = QPainter(self)
+        painter.drawImage(0, 0, img)
+
+    def resizeEvent(self, event):
+        size = event.size()
+        self.width = size.width()
+        self.height = size.height()
+        self.screen = pygame.Surface((self.width, self.height))
+
+    # ---------------------- UPDATE ----------------------
+
+    def update_frame(self):
+        if not self.hasFocus():
+            self.keys_down.clear()
+
+        self.scene_manager.update()
+        self.update()  # triggers paintEvent
+
+    # ---------------------- INPUT ----------------------
+
+    def keyPressEvent(self, event):
+        self.keys_down.add(event.key())
+
+    def keyReleaseEvent(self, event):
+        self.keys_down.discard(event.key())

VertexEngine/example.py

@@ -0,0 +1,59 @@
+from PyQt6.QtWidgets import QApplication
+from engine import GameEngine
+import pygame
+from scenes import Scene
+from assets import AssetManager
+from audio import AudioManager
+import sys
+class MyScene(Scene):
+    def __init__(self, engine):
+        super().__init__(engine)
+        self.assets = AssetManager()
+        self.assets.load_image("ball", "ball.png")
+        self.x = 100
+        self.y = 100
+        self.speed = 5
+        self.width = engine.width
+        self.height = engine.height
+
+    def update(self):
+        # Process pygame events
+        for event in pygame.event.get():
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_LEFT:
+                    self.x -= self.speed
+                elif event.key == pygame.K_RIGHT:
+                    self.x += self.speed
+                elif event.key == pygame.K_UP:
+                    self.y -= self.speed
+                elif event.key == pygame.K_DOWN:
+                    self.y += self.speed
+
+        # Clamp the ball inside the engine window
+        self.x = max(0, min(self.x, self.width - 50))
+        self.y = max(0, min(self.y, self.height - 50))
+
+    def draw(self, surface):
+        surface.fill((0, 0, 0))  # clear screen
+        ball = self.assets.get_image("ball")
+        if ball:
+            ball_scaled = pygame.transform.scale(ball, (55, 50))
+            surface.blit(ball_scaled, (self.x, self.y))
+        else:
+            pygame.draw.circle(surface, (255, 0, 0), (self.x, self.y), 25)
+
+app = QApplication(sys.argv)  # ✅ must be first
+
+engine = GameEngine()
+engine.resize(800, 600)
+
+# Create scene and add to manager
+my_scene = MyScene(engine)
+engine.scene_manager.add_scene("main", my_scene)
+engine.scene_manager.switch_to("main")  # make it the active scene
+
+# Show the engine
+engine.show()
+
+# Start the PyQt6 event loop
+sys.exit(app.exec())

VertexEngine/examples/games/Dodge/main.py

@@ -0,0 +1,233 @@
+import sys
+import random
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt
+
+from VertexEngine.engine import GameEngine
+from VertexEngine.scenes import Scene
+from VertexEngine import VertexScreen
+from VertexEngine.InputSystem.KeyInputs import Input
+
+# =====================
+# CONFIG
+# =====================
+VIRTUAL_WIDTH = 800
+VIRTUAL_HEIGHT = 450
+
+
+#class ScreenScaler:
+#    def __init__(self, engine):
+#        self.engine = engine
+#    @property
+#    def scale(self):
+#        return min(
+#            self.engine.width / VIRTUAL_WIDTH,
+#            self.engine.height / VIRTUAL_HEIGHT,
+#        )
+#    @property
+#    def offset_x(self):
+#        return int((self.engine.width - VIRTUAL_WIDTH * self.scale) / 2)
+#    @property
+#    def offset_y(self):
+#        return int((self.engine.height - VIRTUAL_HEIGHT * self.scale) / 2)
+#    def rect(self, x, y, w, h):
+#        s = self.scale
+#        return (
+#            int(x * s) + self.offset_x,
+#            int(y * s) + self.offset_y,
+#            int(w * s),
+#            int(h * s),
+#        )
+#    def pos(self, x, y):
+#        s = self.scale
+#        return (
+#            int(x * s) + self.offset_x,
+#            int(y * s) + self.offset_y,
+#        )
+class ScreenScaler:
+    def __init__(self, engine):
+        self.engine = engine
+
+    @property
+    def scale(self):
+        return min(
+            self.engine.width / VIRTUAL_WIDTH,
+            self.engine.height / VIRTUAL_HEIGHT,
+        )
+    
+    # 👇 NO CENTERING
+    @property
+    def offset_x(self):
+        return 0
+    
+    @property
+    def offset_y(self):
+        return 0
+    
+    def rect(self, x, y, w, h):
+        s = self.scale
+        return (
+            int(x * s),
+            int(y * s),
+            int(w * s),
+            int(h * s),
+        )
+    
+    def pos(self, x, y):
+        s = self.scale
+        return int(x * s), int(y * s)
+# =====================
+# GAME OBJECTS
+# =====================
+class Player:
+    def __init__(self):
+        self.x = 230
+        self.y = 300
+        self.w = 40
+        self.h = 40
+        self.vel_y = 0
+        self.on_ground = True
+
+    def update(self):
+        speed = 5
+
+        if Input.is_pressed("a") or Input.is_pressed("left"):
+            self.x -= speed
+        if Input.is_pressed("d") or Input.is_pressed("right"):
+            self.x += speed
+
+        if self.x > VIRTUAL_WIDTH:
+            self.x = 0
+        
+        if self.x < 0:
+            self.x = VIRTUAL_WIDTH
+
+        if self.on_ground and Input.is_just_pressed("space"):
+            self.vel_y = -15
+            self.on_ground = False
+
+        self.vel_y += 1
+        self.y += self.vel_y
+
+        if self.y >= 300:
+            self.y = 300
+            self.vel_y = 0
+            self.on_ground = True
+        print(self.x)
+
+class Block:
+    def __init__(self):
+        self.size = 40
+        self.x = random.randint(0, VIRTUAL_WIDTH - self.size)
+        self.y = -self.size
+        self.speed = random.randint(4, 8)
+
+    def update(self):
+        self.y += self.speed
+
+
+# =====================
+# SCENE
+# =====================
+class MainScene(Scene):
+    def __init__(self, engine):
+        super().__init__(engine)
+        self.scaler = ScreenScaler(engine)
+
+        self.player = Player()
+        self.blocks = []
+        self.dead = False
+
+    def update(self):
+        if not self.dead:
+            self.player.update()
+
+            if random.random() < 0.03:
+                self.blocks.append(Block())
+
+            for b in self.blocks:
+                b.update()
+                if (
+                    self.player.x < b.x + b.size and
+                    self.player.x + self.player.w > b.x and
+                    self.player.y < b.y + b.size and
+                    self.player.y + self.player.h > b.y
+                ):
+                    self.dead = True
+
+            self.blocks = [b for b in self.blocks if b.y < VIRTUAL_HEIGHT]
+
+        Input.input_update()
+
+    def draw(self, surface):
+        s = self.scaler
+
+        # background
+        VertexScreen.Draw.rect(
+            VertexScreen.Draw,
+            surface,
+            (15, 15, 15),
+            s.rect(0, 0, VIRTUAL_WIDTH, VIRTUAL_HEIGHT),
+        )
+
+        # player
+        VertexScreen.Draw.rect(
+            VertexScreen.Draw,
+            surface,
+            (0, 255, 255),
+            s.rect(self.player.x, self.player.y, self.player.w, self.player.h),
+        )
+
+        # blocks
+        for b in self.blocks:
+            VertexScreen.Draw.rect(
+                VertexScreen.Draw,
+                surface,
+                (255, 0, 0),
+                s.rect(b.x, b.y, b.size, b.size),
+            )
+
+        # death text
+        if self.dead:
+            deathfont = VertexScreen.Font(None, 24)
+            deathfont.draw(
+                surface,
+                "DOGPILED",
+                s.pos(VIRTUAL_WIDTH // 2, VIRTUAL_HEIGHT // 2)
+            )
+
+
+# =====================
+# ENGINE (Qt INPUT HERE)
+# =====================
+class DogpileEngine(GameEngine):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+
+    def keyPressEvent(self, event):
+        Input.key_down(event.key())
+
+    def keyReleaseEvent(self, event):
+        Input.key_up(event.key())
+
+
+# =====================
+# RUN
+# =====================
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+
+    engine = DogpileEngine(
+        fps=60,
+        width=1000,
+        height=800,
+    )
+    engine.setWindowTitle("Dogpile Dodger (VertexEngine)")
+    engine.setMinimumSize(VIRTUAL_WIDTH, VIRTUAL_HEIGHT)
+    engine.show()
+
+    scene = MainScene(engine)
+    engine.scene_manager.set_scene(scene)
+
+    sys.exit(app.exec())

VertexEngine/examples/games/platformer/main.py

@@ -0,0 +1,205 @@
+"""
+This is a simple single scene platformer, made in the Vertex Game Engine.
+
+This  teaches you:
+Basics of Asset rendering
+Scenes
+Game Engine
+rendering to a screen
+handle input
+dictionaries
+physics
+update and drawing
+"""
+
+from VertexEngine.engine import GameEngine
+from VertexEngine.scenes import Scene
+from VertexEngine import VertexScreen
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt
+import sys
+from VertexEngine.audio import AudioManager
+import pygame
+import os
+# 🔽 WORLD SCALE
+SCALE = 0.5
+
+# 🔽 Physics (scaled)
+GRAVITY = 1.2 * SCALE
+JUMP_FORCE = -22 * SCALE
+MOVE_SPEED = 8 * SCALE
+GROUND_Y = 300 * SCALE
+maindir = os.path.split(os.path.abspath(__file__))[0]
+coin_img = pygame.image.load(maindir + "/data/coin.png")
+coin_img = pygame.transform.scale(
+    coin_img,
+    (32 * SCALE, 32 * SCALE)
+)
+
+class Main(Scene):
+    def __init__(self, engine):
+        super().__init__(engine)
+        self.world_offset_y = engine.height // 2
+        self.score = 0
+        self.coins = [
+            {"x": 200, "y": -35 * SCALE, "collected": False},
+            {"x": 50,   "y": 80  * SCALE, "collected": False},
+            {"x": 380,  "y": -300 * SCALE, "collected": False},
+        ]
+        self.platforms = [
+            (200, 1 * SCALE, 200 * SCALE, 20 * SCALE),
+            (360, -200 * SCALE, 200 * SCALE, 20 * SCALE),
+            (0,   120 * SCALE, 220 * SCALE, 20 * SCALE),
+            (350, 200 * SCALE, 180 * SCALE, 20 * SCALE),
+        ]
+     
+        # 🔽 Player (scaled)
+        self.w = int(80 * SCALE)
+        self.h = int(80 * SCALE)
+
+        self.x = 0
+        self.y = 0
+
+        self.vx = 0
+        self.vy = 0
+        self.on_ground = False
+
+        self.keys = set()
+
+    # --- INPUT ---
+    def keyPressEvent(self, event):
+        self.keys.add(event.key())
+
+    def keyReleaseEvent(self, event):
+        self.keys.discard(event.key())
+
+    # --- UPDATE ---
+    def update(self):
+        self.vx = 0
+
+        if Qt.Key.Key_A in self.keys:
+            self.vx = -MOVE_SPEED
+        if Qt.Key.Key_D in self.keys:
+            self.vx = MOVE_SPEED
+
+        if Qt.Key.Key_Space in self.keys and self.on_ground:
+            self.vy = JUMP_FORCE
+            self.on_ground = False
+
+        # Gravity
+        self.vy += GRAVITY
+
+        # Apply movement
+        self.x += self.vx
+        self.y += self.vy
+
+        self.on_ground = False
+
+        for coin in self.coins:
+            if coin["collected"]:
+                continue
+            
+            cx = coin["x"]
+            cy = coin["y"]
+            cw = coin_img.get_width()
+            ch = coin_img.get_height()
+
+            if (
+                self.x < cx + cw and
+                self.x + self.w > cx and
+                self.y < cy + ch and
+                self.y + self.h > cy
+            ):
+                coin["collected"] = True
+                self.score += 1
+                print("Coin collected! Score:", self.score)
+
+
+        # --- PLATFORM COLLISIONS ---
+        for px, py, pw, ph in self.platforms:
+            if (
+                self.vy >= 0 and
+                self.x + self.w > px and
+                self.x < px + pw and
+                self.y + self.h > py and
+                self.y + self.h < py + ph + self.vy + 1
+            ):
+                self.y = py - self.h
+                self.vy = 0
+                self.on_ground = True
+
+        # --- GROUND COLLISION ---
+        if self.y + self.h >= GROUND_Y:
+            self.y = GROUND_Y - self.h
+            self.vy = 0
+            self.on_ground = True
+
+
+    # --- DRAW ---
+    def draw(self, surface):
+        oy = self.world_offset_y  # visual offset
+
+        # Background
+        VertexScreen.Draw.rect(
+            VertexScreen.Draw,
+            surface,
+            (30, 30, 30),
+            (0, 0, self.engine.width, self.engine.height)
+        )
+
+        # Ground (shifted DOWN)
+        VertexScreen.Draw.rect(
+            VertexScreen.Draw,
+            surface,
+            (50, 200, 50),
+            (-2000 * SCALE, GROUND_Y + oy, 4000 * SCALE, 200 * SCALE)
+        )
+
+        # Player (shifted DOWN)
+        VertexScreen.Draw.rect(
+            VertexScreen.Draw,
+            surface,
+            (255, 100, 100),
+            (self.x, self.y + oy, self.w, self.h)
+        )
+
+        # Coins
+        for coin in self.coins:
+            if coin["collected"]:
+                continue
+            
+            surface.blit(
+                coin_img,
+                (coin["x"], coin["y"] + oy)
+            )
+
+        # Platforms
+        for px, py, pw, ph in self.platforms:
+            VertexScreen.Draw.rect(
+                VertexScreen.Draw,
+                surface,
+                (100, 180, 255),
+                (px, py + oy, pw, ph)
+            )
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+
+    engine = GameEngine(
+        fps=60,
+        width=1920,
+        height=1080,
+    )
+
+    engine.setWindowTitle("Vertex Platformer (Scaled World)")
+
+    engine.show()
+
+    main = Main(engine)
+    engine.scene_manager.add_scene("main", main)
+    engine.scene_manager.switch_to("main")
+
+    engine.keyPressEvent = main.keyPressEvent
+    engine.keyReleaseEvent = main.keyReleaseEvent
+
+    app.exec()

VertexEngine/examples/games/snake/main.py

@@ -0,0 +1,135 @@
+import sys
+import random
+import pygame
+
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt
+
+from VertexEngine.engine import GameEngine
+from VertexEngine.scenes import Scene
+
+# =============================
+# CONFIG
+# =============================
+WIDTH = 800
+HEIGHT = 600
+TILE = 30
+FPS = 60
+GRID_W = WIDTH // TILE
+GRID_H = HEIGHT // TILE
+
+# =============================
+# SNAKE SCENE
+# =============================
+class SnakeScene(Scene):
+    def __init__(self, engine):
+        super().__init__(engine)
+
+        self.snake = [(10, 10)]
+        self.direction = (1, 0)
+        self.next_direction = self.direction
+
+        self.food = self.spawn_food()
+        self.dead = False
+
+        self.tick = 0
+        self.speed = 8  # lower = faster
+
+    def spawn_food(self):
+        return (
+            random.randrange(GRID_W),
+            random.randrange(GRID_H)
+        )
+
+    def set_direction(self, d):
+        # Prevent instant reverse
+        if (-d[0], -d[1]) != self.direction:
+            self.next_direction = d
+
+    def update(self):
+        if self.dead:
+            return
+
+        self.tick += 1
+        if self.tick < self.speed:
+            return
+        self.tick = 0
+
+        self.direction = self.next_direction
+
+        hx, hy = self.snake[0]
+        dx, dy = self.direction
+        new_head = (hx + dx, hy + dy)
+
+        # Death checks
+        if (
+            new_head in self.snake or
+            new_head[0] < 0 or new_head[1] < 0 or
+            new_head[0] >= WIDTH // TILE or
+            new_head[1] >= HEIGHT // TILE
+        ):
+            print("💀 GAME OVER")
+            self.dead = True
+            return
+
+        self.snake.insert(0, new_head)
+
+        if new_head == self.food:
+            self.food = self.spawn_food()
+        else:
+            self.snake.pop()
+
+    def draw(self, screen):
+        screen.fill((0, 0, 0))
+
+        for x, y in self.snake:
+            pygame.draw.rect(
+                screen,
+                (0, 255, 0),
+                (x * TILE, y * TILE, TILE, TILE)
+            )
+
+        fx, fy = self.food
+        pygame.draw.rect(
+            screen,
+            (255, 0, 0),
+            (fx * TILE, fy * TILE, TILE, TILE)
+        )
+
+# =============================
+# BOOTSTRAP (QT FIRST OR DIE)
+# =============================
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+
+    engine = GameEngine(
+        width=WIDTH,
+        height=HEIGHT,
+        fps=FPS
+    )
+
+    engine.setWindowTitle("Snake 🐍 — RC Survivor Edition")
+    engine.show()
+
+    scene = SnakeScene(engine)
+    engine.scene_manager.add_scene("main", scene)
+    engine.scene_manager.switch_to("main")
+
+    # =============================
+    # 🔑 QT INPUT — THIS IS THE FIX
+    # =============================
+    def engine_key_press(event):
+        key = event.key()
+
+        if key == Qt.Key.Key_Up:
+            scene.set_direction((0, -1))
+        elif key == Qt.Key.Key_Down:
+            scene.set_direction((0, 1))
+        elif key == Qt.Key.Key_Left:
+            scene.set_direction((-1, 0))
+        elif key == Qt.Key.Key_Right:
+            scene.set_direction((1, 0))
+
+    engine.keyPressEvent = engine_key_press
+
+    app.exec()