skelform-pygame 0.1.0__tar.gz

skelform_pygame-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: skelform_pygame
+Version: 0.1.0
+Summary: SkelForm runtime for Pygame. Uses the generic runtime
+Author-email: Retropaint <darkglasses1122@gmail.com>
+License-Expression: MIT
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# SkelForm Pygame
+
+SkelForm runtime for Pygame. Uses the [generic runtime](https://pypi.org/project/skelform-python/)

skelform_pygame-0.1.0/README.md

@@ -0,0 +1,3 @@
+# SkelForm Pygame
+
+SkelForm runtime for Pygame. Uses the [generic runtime](https://pypi.org/project/skelform-python/)

skelform_pygame-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "skelform_pygame"
+version = "0.1.0"
+authors = [
+  { name="Retropaint", email="darkglasses1122@gmail.com" },
+]
+description = "SkelForm runtime for Pygame. Uses the generic runtime"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]

skelform_pygame-0.1.0/readme.md

@@ -0,0 +1,3 @@
+# SkelForm Pygame
+
+SkelForm runtime for Pygame. Uses the [generic runtime](https://pypi.org/project/skelform-python/)

skelform_pygame-0.1.0/skelform_pygame/__init__.py

@@ -0,0 +1,116 @@
+import pygame
+import skelform_python
+import math
+import copy
+import zipfile
+import json
+
+
+def load_skelform(path):
+    with zipfile.ZipFile(path, "r") as zip_file:
+        skelform_root = json.load(zip_file.open("armature.json"))
+        texture_img = pygame.image.load(zip_file.open("textures.png"))
+
+    return (skelform_root, texture_img)
+
+
+class AnimOptions:
+    def __init__(
+        self,
+        # Offset armature's position by this much.
+        pos_offset: pygame.Vector2 = pygame.Vector2(0, 0),
+        # Scale armature by a factor of this.
+        scale_factor=0.25,
+        # Should the armature immediately be rendered?
+        # Set to False if you would like to process the armature some more before rendering.
+        render=True,
+    ):
+        self.pos_offset = pos_offset
+        self.scale_factor = scale_factor
+        self.render = render
+
+
+# Animate a SkelForm armature.
+def animate(
+    screen,
+    armature,
+    texture_img,
+    anim_idx,
+    frame=-1,
+    elapsed_time=-1,
+    anim_options=AnimOptions(),
+):
+    if elapsed_time != -1:
+        frame = get_frame_by_time(armature, anim_idx, elapsed_time, False)
+
+    props = skelform_python.animate(armature, anim_idx, frame)
+
+    ao = anim_options
+
+    for prop in props:
+        if prop["tex_idx"] == -1:
+            continue
+
+        tex = armature["textures"][prop["tex_idx"]]
+        tex_surf = clip(
+            texture_img,
+            tex["offset"]["x"],
+            tex["offset"]["y"],
+            tex["size"]["x"],
+            tex["size"]["y"],
+        )
+
+        scale_x = ao.scale_factor * prop["scale"]["x"]
+        scale_y = ao.scale_factor * prop["scale"]["y"]
+        tex_surf = pygame.transform.scale_by(
+            tex_surf,
+            (scale_x, scale_y),
+        )
+
+        # pygame treats positive y as down
+        prop["pos"]["y"] = -prop["pos"]["y"]
+
+        # adjust positions for scale factor
+        # actual scale is already accounted for in core logic
+        prop["pos"]["x"] *= ao.scale_factor
+        prop["pos"]["y"] *= ao.scale_factor
+
+        # push textures back left and up so that it's centered
+        prop["pos"]["x"] -= tex_surf.get_size()[0] / 2
+        prop["pos"]["y"] -= tex_surf.get_size()[1] / 2
+
+        deg = prop["rot"] * 180 / 3.14
+        (tex_surf, rect) = rot_center(tex_surf, tex_surf.get_rect(), deg)
+
+        if not ao.render:
+            continue
+
+        screen.blit(
+            tex_surf,
+            rect.move(
+                prop["pos"]["x"] + ao.pos_offset.x,
+                prop["pos"]["y"] + ao.pos_offset.y,
+            ),
+        )
+
+    return props
+
+
+def get_frame_by_time(armature, anim_idx, elapsed, reverse):
+    return skelform_python.get_frame_by_time(armature, anim_idx, elapsed, reverse)
+
+
+# https://stackoverflow.com/a/71370036
+def clip(surface, x, y, x_size, y_size):  # Get a part of the image
+    handle_surface = surface.copy()  # Sprite that will get process later
+    clipRect = pygame.Rect(x, y, x_size, y_size)  # Part of the image
+    handle_surface.set_clip(clipRect)  # Clip or you can call cropped
+    image = surface.subsurface(handle_surface.get_clip())  # Get subsurface
+    return image.copy()  # Return
+
+
+# https://www.pygame.org/wiki/RotateCenter
+def rot_center(image, rect, angle):
+    rot_image = pygame.transform.rotate(image, angle)
+    rot_rect = rot_image.get_rect(center=rect.center)
+    return rot_image, rot_rect

skelform_pygame-0.1.0/tests/main.py

@@ -0,0 +1,68 @@
+# Example file showing a circle moving on screen
+import pygame
+import zipfile
+import json
+import skelform_pygame
+import time
+
+pygame.init()
+screen = pygame.display.set_mode((1280, 720))
+pygame.display.set_caption("SkelForm Basic Animation")
+clock = pygame.time.Clock()
+running = True
+dt = 0
+
+player_pos = pygame.Vector2(screen.get_width()/2, screen.get_height()/2)
+
+(skelform_root, texture_img) = skelform_pygame.load_skelform("skellington.skf")
+
+moving = False
+
+while running:
+    # poll for events
+    # pygame.QUIT event means the user clicked X to close your window
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # fill the screen with a color to wipe away anything from last frame
+    screen.fill("black")
+
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_w]:
+        player_pos.y -= 300 * dt
+        moving = True
+    if keys[pygame.K_s]:
+        player_pos.y += 300 * dt
+        moving = True
+    if keys[pygame.K_a]:
+        player_pos.x -= 300 * dt
+        moving = True
+    if keys[pygame.K_d]:
+        player_pos.x += 300 * dt
+        moving = True
+
+    anim_idx = 0
+
+    if moving:
+        anim_idx = 1
+
+    skelform_pygame.animate(
+        screen,
+        skelform_root["armature"],
+        texture_img,
+        anim_idx,
+        -1,
+        time.time(),
+        skelform_pygame.AnimOptions(player_pos, 0.25, True),
+    )
+    # flip() the display to put your work on screen
+    pygame.display.flip()
+
+    # limits FPS to 60
+    # dt is delta time in seconds since last frame, used for framerate-
+    # independent physics.
+    dt = clock.tick(60) / 1000
+    moving = False
+
+pygame.quit()