pyscrh 0.1.0__tar.gz

pyscrh-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 魔丸编程
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyscrh-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: pyscrh
+Version: 0.1.0
+Summary: A tiny Scratch-style sprite library built on pygame, for people moving from Scratch to Python.
+Author-email: 魔丸编程 <17516332069@163.com>
+License: MIT License
+        
+        Copyright (c) 2026 魔丸编程
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/CutePandaXJK/pyscrh
+Project-URL: Repository, https://github.com/CutePandaXJK/pyscrh
+Keywords: scratch,pygame,game,sprite,education,beginner
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Education
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.0
+Dynamic: license-file
+
+# pyscrh
+
+A tiny, **Scratch-style** sprite library built on [pygame](https://www.pygame.org/),
+made for people moving from Scratch to Python.
+
+Every Scratch block you know has a short Python equivalent — no game loop,
+no event handling, no surface juggling to remember.
+
+## Install
+
+```bash
+pip install pyscrh
+```
+
+(Requires Python 3.8+ and pygame, which is installed automatically.)
+
+## Quick start
+
+```python
+import pyscrh
+
+apple = Sprite("apple.png")     # load an image (PNG with transparency)
+apple.turnway = "lr"            # flip left-right when bouncing
+
+def forever():
+    apple.move(5)               # walk 5 steps in the current direction
+    apple.edgeb()               # bounce off the screen edge
+    # stop_all()                # call this anywhere to quit the game
+
+clickGF()                       # start the game
+```
+
+Just `import pyscrh` and you're done — `Sprite`, `clickGF`, `stop_all`,
+`WIDTH` and `HEIGHT` are available directly, just like `import pgzrun`.
+
+That's it. The apple walks right, bounces off the right edge, walks left,
+bounces off the left edge, and repeats.
+
+## Scratch → Python cheat sheet
+
+| Scratch block | pyscrh |
+| --- | --- |
+| move 10 steps | `sprite.move(10)` |
+| turn 15° clockwise | `sprite.turnright(15)` |
+| turn 15° counter-clockwise | `sprite.turnleft(15)` |
+| go to x: y: | `sprite.gotoxy(x, y)` |
+| go to random position | `sprite.goto("r")` |
+| glide 1 sec to x: y: | `sprite.glidexy(1, x, y)` |
+| point in direction 90 | `sprite.point(90)` |
+| point towards mouse | `sprite.pointtow("m")` |
+| if on edge, bounce | `sprite.edgeb()` |
+
+## How it works
+
+You only write one required function:
+
+- `forever()` — called once every frame, like Scratch's *forever* block.
+  Put `sprite.move(...)`, `edgeb()`, etc. in here. No `dt` parameter
+  needed; the library handles timing.
+
+An optional `draw()` is also called every frame, *after* all sprites are
+drawn, if you want extra drawing (text, backgrounds, etc.).
+
+Call `clickGF()` to start, and `stop_all()` to close the window and quit.
+pyscrh handles the window, clock, event loop and rendering for you.
+
+## API reference
+
+### `Sprite(image_path, name="")`
+
+Create a sprite from an image file.
+
+| Method | Description |
+| --- | --- |
+| `move(steps)` | Walk `steps` pixels in the current direction. |
+| `turnright(deg)` / `turnleft(deg)` | Rotate by `deg` degrees. |
+| `gotoxy(x, y)` | Jump to `(x, y)`. |
+| `goto("r")` / `goto("m")` | Jump to a random spot / the mouse. |
+| `glidexy(sec, x, y)` | Glide to `(x, y)` over `sec` seconds. |
+| `glideto(sec, "r")` / `glideto(sec, "m")` | Glide to a spot / the mouse. |
+| `point(deg)` | Set direction to `deg` degrees. |
+| `pointtow("r")` / `pointtow("m")` | Face a random direction / the mouse. |
+| `edgeb()` | Bounce off the screen edge. |
+
+| Attribute | Description |
+| --- | --- |
+| `x`, `y` | Center position (read or write). |
+| `angle` | Direction in degrees (0 = right, 90 = down). |
+| `turnway` | `"r"` rotate-bounce, `"lr"` flip-bounce, `"n"` no bounce. |
+
+## License
+
+MIT

pyscrh-0.1.0/README.md

@@ -0,0 +1,93 @@
+# pyscrh
+
+A tiny, **Scratch-style** sprite library built on [pygame](https://www.pygame.org/),
+made for people moving from Scratch to Python.
+
+Every Scratch block you know has a short Python equivalent — no game loop,
+no event handling, no surface juggling to remember.
+
+## Install
+
+```bash
+pip install pyscrh
+```
+
+(Requires Python 3.8+ and pygame, which is installed automatically.)
+
+## Quick start
+
+```python
+import pyscrh
+
+apple = Sprite("apple.png")     # load an image (PNG with transparency)
+apple.turnway = "lr"            # flip left-right when bouncing
+
+def forever():
+    apple.move(5)               # walk 5 steps in the current direction
+    apple.edgeb()               # bounce off the screen edge
+    # stop_all()                # call this anywhere to quit the game
+
+clickGF()                       # start the game
+```
+
+Just `import pyscrh` and you're done — `Sprite`, `clickGF`, `stop_all`,
+`WIDTH` and `HEIGHT` are available directly, just like `import pgzrun`.
+
+That's it. The apple walks right, bounces off the right edge, walks left,
+bounces off the left edge, and repeats.
+
+## Scratch → Python cheat sheet
+
+| Scratch block | pyscrh |
+| --- | --- |
+| move 10 steps | `sprite.move(10)` |
+| turn 15° clockwise | `sprite.turnright(15)` |
+| turn 15° counter-clockwise | `sprite.turnleft(15)` |
+| go to x: y: | `sprite.gotoxy(x, y)` |
+| go to random position | `sprite.goto("r")` |
+| glide 1 sec to x: y: | `sprite.glidexy(1, x, y)` |
+| point in direction 90 | `sprite.point(90)` |
+| point towards mouse | `sprite.pointtow("m")` |
+| if on edge, bounce | `sprite.edgeb()` |
+
+## How it works
+
+You only write one required function:
+
+- `forever()` — called once every frame, like Scratch's *forever* block.
+  Put `sprite.move(...)`, `edgeb()`, etc. in here. No `dt` parameter
+  needed; the library handles timing.
+
+An optional `draw()` is also called every frame, *after* all sprites are
+drawn, if you want extra drawing (text, backgrounds, etc.).
+
+Call `clickGF()` to start, and `stop_all()` to close the window and quit.
+pyscrh handles the window, clock, event loop and rendering for you.
+
+## API reference
+
+### `Sprite(image_path, name="")`
+
+Create a sprite from an image file.
+
+| Method | Description |
+| --- | --- |
+| `move(steps)` | Walk `steps` pixels in the current direction. |
+| `turnright(deg)` / `turnleft(deg)` | Rotate by `deg` degrees. |
+| `gotoxy(x, y)` | Jump to `(x, y)`. |
+| `goto("r")` / `goto("m")` | Jump to a random spot / the mouse. |
+| `glidexy(sec, x, y)` | Glide to `(x, y)` over `sec` seconds. |
+| `glideto(sec, "r")` / `glideto(sec, "m")` | Glide to a spot / the mouse. |
+| `point(deg)` | Set direction to `deg` degrees. |
+| `pointtow("r")` / `pointtow("m")` | Face a random direction / the mouse. |
+| `edgeb()` | Bounce off the screen edge. |
+
+| Attribute | Description |
+| --- | --- |
+| `x`, `y` | Center position (read or write). |
+| `angle` | Direction in degrees (0 = right, 90 = down). |
+| `turnway` | `"r"` rotate-bounce, `"lr"` flip-bounce, `"n"` no bounce. |
+
+## License
+
+MIT

pyscrh-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyscrh"
+version = "0.1.0"
+description = "A tiny Scratch-style sprite library built on pygame, for people moving from Scratch to Python."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+authors = [
+  { name = "魔丸编程", email = "17516332069@163.com" }
+]
+keywords = ["scratch", "pygame", "game", "sprite", "education", "beginner"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Topic :: Games/Entertainment",
+  "Topic :: Education",
+  "Intended Audience :: Education",
+]
+dependencies = [
+  "pygame>=2.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/CutePandaXJK/pyscrh"
+Repository = "https://github.com/CutePandaXJK/pyscrh"

pyscrh-0.1.0/pyscrh/__init__.py

@@ -0,0 +1,322 @@
+"""
+pyscrh
+======
+
+A tiny, **Scratch-style** sprite library built on top of pygame, made for
+people moving from Scratch to Python.
+
+Every Scratch block you know has a short Python equivalent::
+
+    from pyscrh import Sprite, clickGF
+
+    apple = Sprite("apple.png")
+    apple.turnway = "lr"
+
+    def forever():
+        apple.move(5)      # move 5 steps in the current direction
+        apple.edgeb()      # bounce off the edge
+
+    clickGF()              # start the game
+
+The public API is intentionally small: create a :class:`Sprite`, put what
+should repeat forever in a ``forever()`` function, and call :func:`clickGF`
+to start. You never need to touch ``dt`` or the game loop. Call
+:func:`stop_all` at any point to close the window and quit.
+"""
+
+import pygame
+import math
+import random
+import inspect
+import sys
+
+__version__ = "0.1.0"
+
+# --- pygame / window setup (runs on first import) -----------------------
+pygame.init()
+
+WIDTH = 960
+HEIGHT = 720
+_screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("pyscrh")
+_clock = pygame.time.Clock()
+
+# All live sprites. Internal; users never touch this.
+_sprites = []
+
+
+class Sprite:
+    """A single game character, loaded from an image file.
+
+    Parameters
+    ----------
+    image_path : str
+        Full path to the sprite image (PNG with transparency works best).
+    name : str, optional
+        A friendly name. Not required, but handy when you have many sprites.
+
+    Attributes
+    ----------
+    x, y : float
+        Center position of the sprite (read or write directly).
+    angle : float
+        Direction in degrees: ``0`` points right, ``90`` points down.
+    turnway : str
+        How the sprite behaves at the screen edge:
+        ``"r"`` rotates to bounce, ``"lr"`` flips left-right,
+        ``"n"`` does not bounce at all.
+    """
+
+    def __init__(self, image_path, name=""):
+        self.original = pygame.image.load(image_path).convert_alpha()
+        self.width = self.original.get_width()
+        self.height = self.original.get_height()
+
+        # Center position
+        self.x = self.width / 2
+        self.y = self.height / 2
+
+        # Movement state
+        self.angle = 0
+        self.direction_x = 1   # flipped by edgeb on left/right hits
+        self.direction_y = 1   # flipped by edgeb on top/bottom hits
+        self.flip_x = False    # visual horizontal flip
+        self.flip_y = False    # visual vertical flip
+        self.turnway = "r"
+        self.name = name
+
+        # Gliding state (internal, driven by glidexy / glideto)
+        self.glide_target_x = 0
+        self.glide_target_y = 0
+        self.glide_delta_x = 0
+        self.glide_delta_y = 0
+        self.glide_distance = 0.0
+        self.glide_speed = 0.0
+        self.gliding = False
+
+        _sprites.append(self)
+
+    # ------------------------------------------------------------------
+    # Movement
+    # ------------------------------------------------------------------
+    def move(self, steps):
+        """Walk ``steps`` pixels in the current direction.
+
+        Call this once per frame inside your ``update(dt)`` and the sprite
+        keeps walking. Equivalent to Scratch's *move 10 steps*.
+        """
+        rad = math.radians(self.angle)
+        self.x += self.direction_x * steps * math.cos(rad)
+        self.y += self.direction_y * steps * math.sin(rad)
+
+    def turnright(self, degrees):
+        """Turn right by ``degrees``."""
+        self.angle += degrees
+
+    def turnleft(self, degrees):
+        """Turn left by ``degrees``."""
+        self.angle -= degrees
+
+    def gotoxy(self, x, y):
+        """Jump instantly to position ``(x, y)``."""
+        self.x = x
+        self.y = y
+
+    def goto(self, target):
+        """Jump instantly to a target.
+
+        Parameters
+        ----------
+        target : str
+            ``"r"`` for a random spot, ``"m"`` for the mouse position.
+        """
+        if target == "r":
+            self.gotoxy(random.randint(0, WIDTH), random.randint(0, HEIGHT))
+        elif target == "m":
+            self.gotoxy(*pygame.mouse.get_pos())
+
+    # ------------------------------------------------------------------
+    # Gliding
+    # ------------------------------------------------------------------
+    def glidexy(self, seconds, x, y):
+        """Glide smoothly to ``(x, y)`` over ``seconds`` seconds."""
+        if seconds <= 0:
+            return
+        distance = math.hypot(x - self.x, y - self.y)
+        if distance < 1e-9:
+            self.gliding = False
+            return
+        self.glide_target_x = x
+        self.glide_target_y = y
+        self.glide_delta_x = x - self.x
+        self.glide_delta_y = y - self.y
+        self.glide_distance = distance
+        self.glide_speed = distance / seconds
+        self.gliding = True
+
+    def glideto(self, seconds, target):
+        """Glide smoothly over ``seconds`` seconds.
+
+        Parameters
+        ----------
+        seconds : float
+            How long the glide takes.
+        target : str
+            ``"r"`` for a random spot, ``"m"`` for the mouse position.
+        """
+        if target == "r":
+            self.glidexy(seconds,
+                         random.randint(0, WIDTH),
+                         random.randint(0, HEIGHT))
+        elif target == "m":
+            self.glidexy(seconds, *pygame.mouse.get_pos())
+
+    # ------------------------------------------------------------------
+    # Direction
+    # ------------------------------------------------------------------
+    def point(self, degrees):
+        """Set the direction to ``degrees`` (0 = right, 90 = down)."""
+        self.angle = degrees
+
+    def pointtow(self, target):
+        """Point towards something.
+
+        Parameters
+        ----------
+        target : str
+            ``"r"`` for a random direction, ``"m"`` to face the mouse.
+        """
+        if target == "r":
+            self.angle = random.randint(0, 360)
+        elif target == "m":
+            mouse_x, mouse_y = pygame.mouse.get_pos()
+            self.angle = math.degrees(math.atan2(
+                mouse_y - self.y, mouse_x - self.x))
+
+    # ------------------------------------------------------------------
+    # Edge bouncing
+    # ------------------------------------------------------------------
+    def edgeb(self):
+        """Bounce off the screen edge.
+
+        Equivalent to Scratch's *if on edge, bounce*. The horizontal /
+        vertical direction flips independently, and the sprite is visually
+        flipped according to :attr:`turnway`.
+        """
+        left = self.x - self.width / 2
+        right = self.x + self.width / 2
+        top = self.y - self.height / 2
+        bottom = self.y + self.height / 2
+
+        if self.turnway == "n":
+            return
+
+        if right > WIDTH:
+            self.x = WIDTH - self.width / 2
+            self.direction_x = -self.direction_x
+            self.flip_x = not self.flip_x
+        elif left < 0:
+            self.x = self.width / 2
+            self.direction_x = -self.direction_x
+            self.flip_x = not self.flip_x
+
+        if bottom > HEIGHT:
+            self.y = HEIGHT - self.height / 2
+            self.direction_y = -self.direction_y
+            if self.turnway == "r":
+                self.flip_y = not self.flip_y
+        elif top < 0:
+            self.y = self.height / 2
+            self.direction_y = -self.direction_y
+            if self.turnway == "r":
+                self.flip_y = not self.flip_y
+
+    # ------------------------------------------------------------------
+    # Internal per-frame hooks (called by clickGF, not by you)
+    # ------------------------------------------------------------------
+    def _update(self, dt):
+        """Advance an in-progress glide. Regular movement is done by move()."""
+        if not self.gliding:
+            return
+        remaining = math.hypot(self.glide_target_x - self.x,
+                               self.glide_target_y - self.y)
+        step = self.glide_speed * dt
+        if remaining <= step:
+            self.x = self.glide_target_x
+            self.y = self.glide_target_y
+            self.gliding = False
+        else:
+            self.x += self.glide_delta_x / self.glide_distance * step
+            self.y += self.glide_delta_y / self.glide_distance * step
+
+    def _draw(self, surface):
+        """Render this sprite onto ``surface``."""
+        image = self.original
+        if self.turnway == "r":
+            image = pygame.transform.rotate(image, self.angle)
+        if self.flip_x:
+            image = pygame.transform.flip(image, True, False)
+        if self.flip_y:
+            image = pygame.transform.flip(image, False, True)
+        rect = image.get_rect(center=(self.x, self.y))
+        surface.blit(image, rect)
+
+
+def clickGF():
+    """Start the game loop.
+
+    It automatically looks up ``forever()`` in the module that called it and
+    calls it once every frame, like Scratch's *forever* block. You don't
+    need to know about ``dt`` — the library handles timing internally.
+
+    An optional ``draw()`` is also called every frame, *after* all sprites
+    are drawn, if you want extra drawing. Close the window to quit, or call
+    :func:`stop_all` to quit from code.
+    """
+    frame = inspect.currentframe()
+    caller_globals = frame.f_back.f_globals
+    del frame
+    user_forever = caller_globals.get("forever")
+    user_draw = caller_globals.get("draw")
+
+    running = True
+    while running:
+        dt = _clock.tick(60) / 1000  # seconds since last frame (internal use)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+
+        if user_forever is not None:
+            user_forever()
+        for sprite in _sprites:
+            sprite._update(dt)
+
+        _screen.fill((0, 0, 0))
+        for sprite in _sprites:
+            sprite._draw(_screen)
+        if user_draw is not None:
+            user_draw()
+        pygame.display.flip()
+
+    pygame.quit()
+
+
+def stop_all():
+    """Close the window and stop the program.
+
+    Equivalent to Scratch's *stop all* block. Call it from anywhere, e.g.
+    inside ``forever()`` when your game logic says the program should end.
+    """
+    pygame.quit()
+    sys.exit()
+
+
+# 魔法：让用户只写 "import pyscrh" 就能直接用 Sprite / clickGF / stop_all，
+# 不用再写 "from pyscrh import *"（和 pgzrun 的体验一致）。
+import __main__
+__main__.Sprite = Sprite
+__main__.clickGF = clickGF
+__main__.stop_all = stop_all
+__main__.WIDTH = WIDTH
+__main__.HEIGHT = HEIGHT

pyscrh-0.1.0/pyscrh.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: pyscrh
+Version: 0.1.0
+Summary: A tiny Scratch-style sprite library built on pygame, for people moving from Scratch to Python.
+Author-email: 魔丸编程 <17516332069@163.com>
+License: MIT License
+        
+        Copyright (c) 2026 魔丸编程
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/CutePandaXJK/pyscrh
+Project-URL: Repository, https://github.com/CutePandaXJK/pyscrh
+Keywords: scratch,pygame,game,sprite,education,beginner
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Education
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.0
+Dynamic: license-file
+
+# pyscrh
+
+A tiny, **Scratch-style** sprite library built on [pygame](https://www.pygame.org/),
+made for people moving from Scratch to Python.
+
+Every Scratch block you know has a short Python equivalent — no game loop,
+no event handling, no surface juggling to remember.
+
+## Install
+
+```bash
+pip install pyscrh
+```
+
+(Requires Python 3.8+ and pygame, which is installed automatically.)
+
+## Quick start
+
+```python
+import pyscrh
+
+apple = Sprite("apple.png")     # load an image (PNG with transparency)
+apple.turnway = "lr"            # flip left-right when bouncing
+
+def forever():
+    apple.move(5)               # walk 5 steps in the current direction
+    apple.edgeb()               # bounce off the screen edge
+    # stop_all()                # call this anywhere to quit the game
+
+clickGF()                       # start the game
+```
+
+Just `import pyscrh` and you're done — `Sprite`, `clickGF`, `stop_all`,
+`WIDTH` and `HEIGHT` are available directly, just like `import pgzrun`.
+
+That's it. The apple walks right, bounces off the right edge, walks left,
+bounces off the left edge, and repeats.
+
+## Scratch → Python cheat sheet
+
+| Scratch block | pyscrh |
+| --- | --- |
+| move 10 steps | `sprite.move(10)` |
+| turn 15° clockwise | `sprite.turnright(15)` |
+| turn 15° counter-clockwise | `sprite.turnleft(15)` |
+| go to x: y: | `sprite.gotoxy(x, y)` |
+| go to random position | `sprite.goto("r")` |
+| glide 1 sec to x: y: | `sprite.glidexy(1, x, y)` |
+| point in direction 90 | `sprite.point(90)` |
+| point towards mouse | `sprite.pointtow("m")` |
+| if on edge, bounce | `sprite.edgeb()` |
+
+## How it works
+
+You only write one required function:
+
+- `forever()` — called once every frame, like Scratch's *forever* block.
+  Put `sprite.move(...)`, `edgeb()`, etc. in here. No `dt` parameter
+  needed; the library handles timing.
+
+An optional `draw()` is also called every frame, *after* all sprites are
+drawn, if you want extra drawing (text, backgrounds, etc.).
+
+Call `clickGF()` to start, and `stop_all()` to close the window and quit.
+pyscrh handles the window, clock, event loop and rendering for you.
+
+## API reference
+
+### `Sprite(image_path, name="")`
+
+Create a sprite from an image file.
+
+| Method | Description |
+| --- | --- |
+| `move(steps)` | Walk `steps` pixels in the current direction. |
+| `turnright(deg)` / `turnleft(deg)` | Rotate by `deg` degrees. |
+| `gotoxy(x, y)` | Jump to `(x, y)`. |
+| `goto("r")` / `goto("m")` | Jump to a random spot / the mouse. |
+| `glidexy(sec, x, y)` | Glide to `(x, y)` over `sec` seconds. |
+| `glideto(sec, "r")` / `glideto(sec, "m")` | Glide to a spot / the mouse. |
+| `point(deg)` | Set direction to `deg` degrees. |
+| `pointtow("r")` / `pointtow("m")` | Face a random direction / the mouse. |
+| `edgeb()` | Bounce off the screen edge. |
+
+| Attribute | Description |
+| --- | --- |
+| `x`, `y` | Center position (read or write). |
+| `angle` | Direction in degrees (0 = right, 90 = down). |
+| `turnway` | `"r"` rotate-bounce, `"lr"` flip-bounce, `"n"` no bounce. |
+
+## License
+
+MIT

pyscrh-0.1.0/pyscrh.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+pyscrh/__init__.py
+pyscrh.egg-info/PKG-INFO
+pyscrh.egg-info/SOURCES.txt
+pyscrh.egg-info/dependency_links.txt
+pyscrh.egg-info/requires.txt
+pyscrh.egg-info/top_level.txt

pyscrh-0.1.0/pyscrh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyscrh-0.1.0/pyscrh.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame>=2.0

pyscrh-0.1.0/pyscrh.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyscrh

pyscrh-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+