From 8a40f24d653d25b8bf0634fe62fa799e38b95587 Mon Sep 17 00:00:00 2001
From: Wobbl <emil@i21k.de>
Date: Thu, 18 Jul 2024 10:53:51 +0200
Subject: [PATCH] Got the engine working.

---
 assets/stacked_sprites/Building.png      | Bin 0 -> 4617 bytes
 assets/stacked_sprites/Robot.png         | Bin 0 -> 1348 bytes
 sprite_stacking_engine/cache.py          |  66 +++++++++++++++++++++++
 sprite_stacking_engine/engine.py         |  53 ++++++++++++++++++
 sprite_stacking_engine/player.py         |  58 ++++++++++++++++++++
 sprite_stacking_engine/scene.py          |  42 +++++++++++++++
 sprite_stacking_engine/settings.py       |  31 +++++++++++
 sprite_stacking_engine/stacked_sprite.py |  47 ++++++++++++++++
 8 files changed, 297 insertions(+)
 create mode 100644 assets/stacked_sprites/Building.png
 create mode 100644 assets/stacked_sprites/Robot.png
 create mode 100644 sprite_stacking_engine/cache.py
 create mode 100755 sprite_stacking_engine/engine.py
 create mode 100644 sprite_stacking_engine/player.py
 create mode 100644 sprite_stacking_engine/scene.py
 create mode 100644 sprite_stacking_engine/settings.py
 create mode 100644 sprite_stacking_engine/stacked_sprite.py

diff --git a/assets/stacked_sprites/Building.png b/assets/stacked_sprites/Building.png
new file mode 100644
index 0000000000000000000000000000000000000000..8268a984e29f7f473c409ab5cc55355b9bb84f34
GIT binary patch
literal 4617
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
Xh?YLxCP`sovXK3GN1H0^>%adGc@w^f

literal 0
HcmV?d00001

diff --git a/assets/stacked_sprites/Robot.png b/assets/stacked_sprites/Robot.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c59f36e751c8ce08fc9d62bf93370f77f6472c3
GIT binary patch
literal 1348
zcmV-K1-tr*P)<h;3K|Lk000e1NJLTq009sH000^Y1^@s6f93<n000FGNkl<Zc%1EA
zzi-<*5IzMNqFEUOWaxjO@j;y)G$&J0kM>$XQvr`nN39CFrlXTi@vOcn!b7M014W0R
zZ+eJlb<-PM`kiG;Jc=iak@*2aEQ<H(c;p>_hzx*3Bcdp(IPy3+j1@<H5hqDf$u3>_
zvMjeQDo+$e8+puw)7qS0Jgdvr?{VI?vZy#H_Gl{$mBYlQbq?9@ed@ts53YI{L)~JY
zu71k`&ITg8r~#x&UR<gGLgi2e5ETc-9vmE|HnoYv7Mt3_!BsE1e%sp!Bu!J8&*z)_
z`Fsv(nv!IrD5~1>rfGU`QwMBIoo5&-o4zCt4tv-FTk2Ni)$!Zj0ti+{CwOo`C%Eh*
z5ZTl~Oks=T+7g7uRJZt@RKM*tfH*ifj2pcM5D~%Z!=gijExjcNZ0Rj+>G{W0xA>h@
zzwIr6)Q3MWF^CjJ;c?{QfGrKx77kki83$~sTaj1CZ+i(KS(bT18GPYqDqtB(dJ_l!
z+muG(kiB~d4wJGp<<$-B_`O|p;LyX>ZM!bIIsowa?ckt%7FFfr;!ta=pO?S|Q4|@;
z0{~2}7DgQJ@4k1I$2=xwaj+l993&SP7Zm`&a=FxsQdmwn;lu1~{c!e{<dm;rEr+KP
z53@7)HTetxpyW7NOu;L5(;sGMWE}uN$}tq)-+hN~*Ha^oZ`V_pTrFU6HDS`qVT?HD
zaQ@Y5wMozOoaA(I9B;`5L7?+`shrRWU>z8!klEnZ<TIQsrXmnEVv}cfD}7Gc2;}>|
z()NNUj^j;Qp662err=SQWrgK2k4%T3Uq6xLRXh}qSMR>Sk56v~<#_e(3jhF_qfHm8
zyx;(!)h(5)i)<GhV<*-DmMe<FOOm82igh;}$FY~^c_scfrG;U*nOiNFOK-i~?O!cD
z&d<*`9RKTd*10S)h#(<?5;eGR!uNfzEXztXES#>xQ<v9;seCKPC7s(Aj#eHbxaxKY
z9CP&iCJ<8>ldl<qW9YJs9ipMPJwGH48?kS_k5;RdvImwy$Z;$na(oI6!w_sJi_K_i
zTsn=8gTofsWDno>Jt2dC+m53k2s-t^oV_;3X}>JXJR8c=C+dx=OCz&^L*^j5PQ$?=
zWZLd^bitP{hspbggz*{($LQhl@zIn5qA03N*FgH%6ee33tEa0#`P8h^-EqkC%knj)
ztB@o~^<wr*Fk$dD5Dupm9QZ4Y4qnO#!~{VQv`+6RHsIi}1tQqggAq=rw9WeH8Q&j5
zFk$%$V+;EF3bQZtx#>z(Mv4t|IBefQRuqMYf<)Djt^^JeZUmwM8+#iY%Oa*Ne^0hI
zWPLn6g+CVS-J-tlw{nQa{MY5>R&V$5^c4QQzb7?VPLAKunl9MJ(U!mKsQA!=2Y?%a
z)Z`o-9CR@F2xRR0K(-c9QTm7HX8__tswm%w=jR;`nf<~r+*z2`;gHE=j<$5Sh<aF~
z5aSU@S7T#@VF+RuYgdT5>-w(S2!x|7CNQ;u;E?g?EP!TN)|iLN!BLhz;TBPOU^D{Z
z8v1h>I!Ti1>FKGHEN5A4#l9C&Z3kW~^?iS9^w4z?^$_88okCza{9ETR9ghAYklkOj
zFDTY=xh!`Y?&d@<5wCCl0f22Alx11z9Hwj90K|2e4)ckB`qFjN5yycmTl8=k7A%$4
z%W-}pWX@mRysfAQ-A)!$@MgC=dRI5}qx=9M<#2EqJN^SjrU02s%A79%0000<MNUMn
GLSTZLvwsc%

literal 0
HcmV?d00001

diff --git a/sprite_stacking_engine/cache.py b/sprite_stacking_engine/cache.py
new file mode 100644
index 0000000..03cde37
--- /dev/null
+++ b/sprite_stacking_engine/cache.py
@@ -0,0 +1,66 @@
+#!/usr/bin/python3
+import pygame.draw
+
+from settings import *
+
+
+class Cache:
+    def __init__(self):
+        self.stacked_sprite_cache = {}
+        self.viewing_angle = 360 // NUM_ANGLES
+        self.outline_thickness = 4
+        self.get_stacked_sprite_cache()
+
+    def get_stacked_sprite_cache(self):
+        for object_name in SPRITE_ATTRS:
+            self.stacked_sprite_cache[object_name] = {
+                "rotated_sprites": {}
+            }
+
+            attrs = SPRITE_ATTRS[object_name]
+            layer_array = self.get_layer_array(attrs)
+            self.run_prerender(object_name, layer_array, attrs)
+
+    def run_prerender(self, object_name, layer_array, attrs):
+        outline = attrs.get("outline", True)
+
+        for angle in range(NUM_ANGLES):
+            surface = pygame.Surface(layer_array[0].get_size())
+            surface = pygame.transform.rotate(surface, angle * self.viewing_angle)
+            sprite_surface = pygame.Surface([
+                surface.get_width(),
+                surface.get_height() + attrs["num_layers"] * attrs["scale"]
+            ])
+
+            sprite_surface.fill(TRANSP_COLOR)
+            sprite_surface.set_colorkey(TRANSP_COLOR)
+
+            for i, layer in enumerate(layer_array):
+                layer = pygame.transform.rotate(layer, angle * self.viewing_angle)
+                sprite_surface.blit(layer, (0, i * attrs["scale"]))
+
+            # get outline
+            if outline:
+                outline_coords = pygame.mask.from_surface(sprite_surface).outline()
+                pygame.draw.polygon(sprite_surface, "black", outline_coords, self.outline_thickness)
+
+            image = pygame.transform.flip(sprite_surface, True, True)
+            self.stacked_sprite_cache[object_name]["rotated_sprites"][angle] = image
+
+    def get_layer_array(self, attrs):
+        # load sprite sheet
+        sprite_sheet = pygame.image.load(attrs["path"]).convert_alpha()
+        # scaling
+        sprite_sheet = pygame.transform.scale(sprite_sheet, vec2(sprite_sheet.get_size()) * attrs["scale"])
+        sheet_width, sheet_height = sprite_sheet.get_size()
+        sprite_width = sheet_width // attrs["num_layers"]
+        # new width to prevent error
+        sheet_width = sprite_width * attrs["num_layers"]
+
+        # get sprites
+        layer_array = []
+        for x in range(0, sheet_width, sprite_width):
+            sprite = sprite_sheet.subsurface((x, 0, sprite_width, sheet_height))
+            layer_array.append(sprite)
+
+        return layer_array
\ No newline at end of file
diff --git a/sprite_stacking_engine/engine.py b/sprite_stacking_engine/engine.py
new file mode 100755
index 0000000..737633e
--- /dev/null
+++ b/sprite_stacking_engine/engine.py
@@ -0,0 +1,53 @@
+#!/usr/bin/python3
+
+import sys
+from settings import *
+from stacked_sprite import StackedSprite
+from cache import Cache
+from player import Player
+from scene import Scene
+
+
+class App:
+    def __init__(self):
+        self.screen = pygame.display.set_mode(RES)
+        self.clock = pygame.time.Clock()
+        self.time = 0
+        self.delta_time = 0.01
+        # groups
+        self.main_group = pygame.sprite.LayeredUpdates()
+        # game objects
+        self.cache = Cache()
+        self.player = Player(self)
+        self.scene = Scene(self)
+
+    def update(self):
+        self.main_group.update()
+        pygame.display.set_caption(f"{self.clock.get_fps(): .1f}")
+        self.delta_time = self.clock.tick(60)
+
+    def draw(self):
+        self.screen.fill(BG_COLOR)
+        self.main_group.draw(self.screen)
+        pygame.display.flip()
+
+    def check_events(self):
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+
+    def get_time(self):
+        self.time = pygame.time.get_ticks() * 0.001
+
+    def run(self):
+        while True:
+            self.check_events()
+            self.get_time()
+            self.update()
+            self.draw()
+
+
+if __name__ == "__main__":
+    app = App()
+    app.run()
diff --git a/sprite_stacking_engine/player.py b/sprite_stacking_engine/player.py
new file mode 100644
index 0000000..d49deee
--- /dev/null
+++ b/sprite_stacking_engine/player.py
@@ -0,0 +1,58 @@
+#!/usr/bin/python3
+
+from settings import *
+import math
+
+
+class Player(pygame.sprite.Sprite):
+    def __init__(self, app):
+        self.app = app
+        self.group = app.main_group
+        super().__init__(self.group)
+
+        self.group.change_layer(self, CENTER.y)
+
+        size = vec2([50, 50])
+        self.image = pygame.Surface(size, pygame.SRCALPHA)
+        pygame.draw.circle(self.image, "red", size / 2, size[0] / 2)
+        self.rect = self.image.get_rect(center=CENTER)
+
+        self.offset = vec2(0)
+        self.inc = vec2(0)
+        self.angle = 0
+        self.diag_move_corr = 1 / math.sqrt(2)
+
+    def control(self):
+        self.inc = vec2(0)
+        speed = PLAYER_SPEED * self.app.delta_time
+        rot_speed = PLAYER_ROT_SPEED * self.app.delta_time
+
+        key_state = pygame.key.get_pressed()
+
+        if key_state[pygame.K_LEFT]:
+            self.angle -= rot_speed
+
+        if key_state[pygame.K_RIGHT]:
+            self.angle += rot_speed
+
+        if key_state[pygame.K_w]:
+            self.inc += vec2(0, -speed).rotate_rad(-self.angle)
+
+        if key_state[pygame.K_s]:
+            self.inc += vec2(0, speed).rotate_rad(-self.angle)
+
+        if key_state[pygame.K_a]:
+            self.inc += vec2(-speed, 0).rotate_rad(-self.angle)
+
+        if key_state[pygame.K_d]:
+            self.inc += vec2(speed, 0).rotate_rad(-self.angle)
+
+        if self.inc.x and self.inc.y:
+            self.inc *= self.diag_move_corr
+
+    def update(self):
+        self.control()
+        self.move()
+
+    def move(self):
+        self.offset += self.inc
\ No newline at end of file
diff --git a/sprite_stacking_engine/scene.py b/sprite_stacking_engine/scene.py
new file mode 100644
index 0000000..fae4082
--- /dev/null
+++ b/sprite_stacking_engine/scene.py
@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+
+from stacked_sprite import *
+from random import uniform
+
+P = "player"
+A, B = "Robot", "Building"
+
+MAP = [
+    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, B, B, B, B],
+    [0, 0, A, A, 0, B, B, B, B],
+    [0, 0, A, A, P, B, B, B, B],
+    [0, 0, A, A, 0, B, B, B, B],
+    [0, 0, 0, 0, 0, B, B, B, B],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+]
+
+MAP_SIZE = MAP_WIDTH, MAP_HEIGHT = vec2(len(MAP), len(MAP[0]))
+MAP_CENTER = MAP_SIZE / 2
+
+
+class Scene:
+    def __init__(self, app):
+        self.app = app
+        self.load_scene()
+
+    def load_scene(self):
+        rand_rot = lambda: uniform(0, 360)
+        rand_pos = lambda pos: pos + vec2(uniform(-0.25, 0.25))
+
+        for j, row in enumerate(MAP):
+            for i, name in enumerate(row):
+                pos = vec2(i, j) + vec2(0.5)
+
+                if name == "player":
+                    self.app.player.offset = pos * TILE_SIZE
+
+                elif name:
+                    StackedSprite(self.app, name=name, pos=rand_pos(pos), rot=rand_rot())
diff --git a/sprite_stacking_engine/settings.py b/sprite_stacking_engine/settings.py
new file mode 100644
index 0000000..011fb09
--- /dev/null
+++ b/sprite_stacking_engine/settings.py
@@ -0,0 +1,31 @@
+#!/usr/bin/python3
+
+import pygame
+
+vec2 = pygame.math.Vector2
+
+RES = WIDTH, HEIGHT = vec2(1400, 800)
+CENTER = H_WIDTH, H_HEIGHT = RES // 2
+TILE_SIZE = 250
+
+PLAYER_SPEED = 0.4
+PLAYER_ROT_SPEED = 0.0015
+
+BG_COLOR = "olivedrab"
+NUM_ANGLES = 180  # multiple of 360
+TRANSP_COLOR = (43, 64, 36)
+
+SPRITE_ATTRS = {
+    "Robot": {
+        "path": "../assets/stacked_sprites/Robot.png",
+        "num_layers": 16,
+        "scale": 8,
+        "y_offset": -8
+    },
+    "Building": {
+        "path": "../assets/stacked_sprites/Building.png",
+        "num_layers": 80,
+        "scale": 4,
+        "y_offset": -40
+    }
+}
\ No newline at end of file
diff --git a/sprite_stacking_engine/stacked_sprite.py b/sprite_stacking_engine/stacked_sprite.py
new file mode 100644
index 0000000..1726319
--- /dev/null
+++ b/sprite_stacking_engine/stacked_sprite.py
@@ -0,0 +1,47 @@
+#!/usr/bin/python3
+import pygame
+
+from settings import *
+import math
+from wobbl_tools import pg
+
+
+class StackedSprite(pygame.sprite.Sprite):
+    def __init__(self, app, name, pos, rot=0):
+        self.app = app
+        self.name = name
+        self.pos = vec2(pos) * TILE_SIZE
+        self.player = self.app.player
+        self.group = self.app.main_group
+        super().__init__(self.group)
+
+        self.attrs = SPRITE_ATTRS[name]
+        self.y_offset = vec2(0, -self.attrs["num_layers"] / 2 * self.attrs["scale"])
+        self.cache = self.app.cache.stacked_sprite_cache
+        self.viewing_angle = app.cache.viewing_angle
+        self.rotated_sprites = self.cache[name]["rotated_sprites"]
+        self.angle = 0
+        self.screen_position = vec2(0)
+        self.rot = (rot % 360) // self.viewing_angle
+
+    def transform(self):
+        pos = self.pos - self.player.offset
+        pos = pos.rotate_rad(self.player.angle)
+        self.screen_position = pos + CENTER
+
+    def change_layer(self):
+        self.group.change_layer(self, self.screen_position.y)
+
+    def get_angle(self):
+        self.angle = -math.degrees(self.player.angle) // self.viewing_angle + self.rot
+        self.angle = int(self.angle % NUM_ANGLES)
+
+    def update(self):
+        self.transform()
+        self.get_angle()
+        self.get_image()
+        self.change_layer()
+
+    def get_image(self):
+        self.image = self.rotated_sprites[self.angle]
+        self.rect = self.image.get_rect(center=self.screen_position + self.y_offset)