pgzero-plus 0.1.0__py3-none-any.whl

pgzero/runner.py

@@ -0,0 +1,233 @@
+from . import storage
+from . import clock
+from . import loaders
+from . import __version__
+from .game import PGZeroGame, DISPLAY_FLAGS
+from types import ModuleType
+from argparse import ArgumentParser
+import warnings
+import sys
+import os
+import pygame
+
+pygame.mixer.pre_init(frequency=22050, size=-16, channels=2)
+pygame.init()
+
+
+def _check_python_ok_for_pygame():
+    """If we're on a Mac, is this a full Framework python?
+
+    There is a problem with PyGame on Macs running in a virtual env.
+    If the Python used is from the venv, it will not allow full window and
+    keyboard interaction. Instead, we need the original framework Python
+    to get PyGame working properly.
+
+    The problem doesn't occur on Linux and Windows.
+    """
+    if sys.platform == "darwin":  # This is a Mac
+        return "Library/Frameworks" in sys.executable
+    else:
+        return True
+
+
+def _substitute_full_framework_python():
+    """Need to change the OS/X Python executable to the full Mac version,
+    while maintaining the virtualenv environment, so things still run
+    in an encapsulated way.
+
+    We do this by extract the paths that virtualenv has added to the system
+    path, and prefixing them to the current PYTHONPATH.
+
+    Then we use os.execv() to start a replacement process that uses the
+    same environment as the previous one.
+    """
+    PYVER = "{}.{}".format(*sys.version_info[:2])
+    base_fw = "/Library/Frameworks/Python.framework/Versions/"
+    framework_python = base_fw + "{pv}/bin/python{pv}".format(pv=PYVER)
+    venv_base = os.environ.get("VIRTUAL_ENV")
+    if not venv_base or not os.path.exists(framework_python):
+        # Do nothing if virtual env hasn't been set up or if we can't
+        # find the framework Python interpreter
+        return
+    venv_paths = [p for p in sys.path if p.startswith(venv_base)]
+    # Need to allow for PYTHONPATH not already existing in environment
+    os.environ["PYTHONPATH"] = ":".join(venv_paths + [os.environ.get("PYTHONPATH", "")]).rstrip(":")
+    # Pass command line args to the new process
+    os.execv(framework_python, ["python", "-m", "pgzero"] + sys.argv[1:])
+
+
+def main():
+
+    # Pygame won't run from a normal virtualenv copy of Python on a Mac
+    if not _check_python_ok_for_pygame():
+        _substitute_full_framework_python()
+
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--fps",
+        action="store_true",
+        help="Print periodic FPS measurements on the terminal.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("game", help="The Pygame Zero game to run (a Python file or directory).")
+    args = parser.parse_args()
+
+    if __debug__:
+        warnings.simplefilter("default", DeprecationWarning)
+
+    try:
+        load_and_run(args.game, fps=args.fps)
+    except NoMainModule as e:
+        sys.exit(e)
+
+
+class NoMainModule(Exception):
+    """Indicate that we couldn't find a main module to run."""
+
+
+def load_and_run(path, *, fps: bool = False):
+    """Load and run the given Python file or directory.
+
+    If a file, run this as the main PGZero game module.
+
+    If a directory, run the first file inside the directory containing:
+
+    * `__main__.py`
+    * `main.py`
+    * `run_game.py`
+    * `<name>.py` where `<name>` is the basename of the directory
+
+    Note that the 'import pgzrun' IDE mode doesn't pass through this entry
+    point, as the module is already loaded.
+
+    """
+    path = path.rstrip(os.sep)
+    try:
+        with open(path, "rb") as f:
+            src = f.read()
+    except FileNotFoundError:
+        raise NoMainModule(f"Error: {path} does not exist.")
+    except (IsADirectoryError, PermissionError):
+        name = os.path.basename(path)
+        for candidate in (
+            "__main__.py",
+            "main.py",
+            "run_game.py",
+            f"{name}.py",
+        ):
+            try:
+                with open(os.path.join(path, candidate), "rb") as f:
+                    src = f.read()
+                    break
+            except FileNotFoundError:
+                pass
+        else:
+            raise NoMainModule(f"""\
+Error: {path} is a directory.
+
+To run a directory with pgzrun, it must contain a file named __main__.py,
+main.py, run_game.py, or a .py file with the same name as the directory.
+
+You can also run a specific file with:
+
+    pgzrun path/to/your/file.py
+""")
+    else:
+        name, _ = os.path.splitext(os.path.basename(path))
+
+    code = compile(src, os.path.basename(path), "exec", dont_inherit=True)
+    mod = ModuleType(name)
+    mod.__file__ = path
+    mod.__name__ = name
+    sys.modules[name] = mod
+
+    # Indicate that we're running with the pgzrun runner
+    # This disables the 'import pgzrun' module
+    sys._pgzrun = True
+
+    prepare_mod(mod)
+    exec(code, mod.__dict__)
+
+    try:
+        run_mod(mod, fps=fps)
+    finally:
+        # Clean some of the state we created, useful in testing
+        pygame.display.quit()
+        clock.clock.clear()
+        del sys.modules[name]
+
+
+def prepare_mod(mod):
+    """Prepare to execute the module code for Pygame Zero.
+
+    To allow the module to load assets, we configure the loader path to
+    load relative to the module's __file__ path.
+
+    When executing the module some things need to already exist:
+
+    * Our extra builtins need to be defined (by copying them into Python's
+      `builtins` module)
+    * A window needs to exist (because we use convert_alpha() to convert
+      image surfaces for blitting to the screen). See open_loading_window().
+
+    """
+    storage.storage._set_filename_from_path(mod.__file__)
+    loaders.set_root(mod.__file__)
+
+    open_loading_window()
+
+    from .game import Game
+    from . import builtins as pgzero_builtins
+    import builtins as python_builtins
+
+    for name in pgzero_builtins.__all__:
+        python_builtins.__dict__.setdefault(name, getattr(pgzero_builtins, name))
+
+    # setdefault() keeps any name that already exists, so these are replaced
+    # explicitly:
+    # * exit: Python already has its own exit(), which doesn't wait for
+    #   sounds to finish playing.
+    # * game: each run starts with a fresh Game, so score and state from an
+    #   earlier run (e.g. in the test suite) don't carry over.
+    python_builtins.exit = pgzero_builtins.exit
+    python_builtins.game = pgzero_builtins.game = Game()
+
+
+def open_loading_window():
+    """Create a hidden window for the game module's top-level code to use.
+
+    Several Pygame surface operations access the state of the screen as a
+    global:
+
+    * Surface.convert_alpha() without arguments converts a surface for fast
+      blitting to the display.
+    * Surface() without flags creates a surface identical to the display
+      format.
+
+    There's no good API to expose what the display format is until we create
+    a window, so we create a hidden one, which lets code like a top-level
+    ``Actor("alien")`` load its image. The expectation is that when we create
+    the real window this will have the same display format and blits etc will
+    still be fast.
+
+    run_mod() closes this window before opening the real one. Resizing it
+    instead would leave the game window off-centre on the screen.
+
+    """
+    # An icon needs to exist before the window is created.
+    PGZeroGame.show_default_icon()
+    pygame.display.set_mode(
+        (100, 100),
+        flags=(DISPLAY_FLAGS & ~pygame.SHOWN) | pygame.HIDDEN,
+    )
+
+
+def run_mod(mod, **kwargs):
+    """Run the module."""
+    # Start from a fresh display so the game window opens centred, rather
+    # than reusing the hidden loading window from prepare_mod().
+    pygame.display.quit()
+    pygame.display.init()
+    PGZeroGame.show_default_icon()
+
+    PGZeroGame(mod, **kwargs).run()

pgzero/screen.py

@@ -0,0 +1,210 @@
+import pygame
+import pygame.draw
+
+from . import ptext
+from .rect import RECT_CLASSES, ZRect
+from . import loaders
+
+
+def round_pos(pos):
+    """Round a tuple position so it can be used for drawing."""
+    try:
+        x, y = pos
+    except TypeError:
+        raise TypeError("Coordinate must be a tuple (not {!r})".format(pos)) from None
+    try:
+        return round(x), round(y)
+    except TypeError:
+        raise TypeError("Coordinate values must be numbers (not {!r})".format(pos)) from None  # noqa
+
+
+def make_color(arg):
+    if isinstance(arg, tuple):
+        return arg
+    return tuple(pygame.Color(arg))
+
+
+class SurfacePainter:
+    """Interface to pygame.draw that is bound to a surface."""
+
+    def __init__(self, screen):
+        self._screen = screen
+
+    @property
+    def _surf(self):
+        return self._screen.surface
+
+    def line(self, start, end, color, width=1):
+        """Draw a line from start to end."""
+        start = round_pos(start)
+        end = round_pos(end)
+        pygame.draw.line(self._surf, make_color(color), start, end, width)
+
+    def circle(self, pos, radius, color, width=1):
+        """Draw a circle."""
+        pos = round_pos(pos)
+        pygame.draw.circle(self._surf, make_color(color), pos, radius, width)
+
+    def filled_circle(self, pos, radius, color):
+        """Draw a filled circle."""
+        pos = round_pos(pos)
+        pygame.draw.circle(self._surf, make_color(color), pos, radius, 0)
+
+    def polygon(self, points, color):
+        """Draw a polygon."""
+        try:
+            iter(points)
+        except TypeError:
+            raise TypeError("screen.draw.filled_polygon() requires an iterable of points to draw") from None  # noqa
+        points = [round_pos(point) for point in points]
+        pygame.draw.polygon(self._surf, make_color(color), points, 1)
+
+    def filled_polygon(self, points, color):
+        """Draw a filled polygon."""
+        try:
+            iter(points)
+        except TypeError:
+            raise TypeError("screen.draw.filled_polygon() requires an iterable of points to draw") from None  # noqa
+        points = [round_pos(point) for point in points]
+        pygame.draw.polygon(self._surf, make_color(color), points, 0)
+
+    def _coerce_rect(self, rect, color_or_size, color, method_name):
+        """Unpack ``(rect, color)`` or ``((x, y), (w, h), color)``.
+
+        Return (pygame.Rect, (l, t, w, h), color).
+        """
+        if isinstance(rect, RECT_CLASSES):
+            if color is None:
+                color = color_or_size
+            elif color_or_size is not None:
+                raise TypeError(f"screen.draw.{method_name}() got too many positional arguments for rect form")
+            l, t, w, h = rect
+        else:
+            try:
+                (l, t), (w, h) = rect, color_or_size
+                l, t, w, h = float(l), float(t), float(w), float(h)
+            except (TypeError, ValueError):
+                raise TypeError(f"screen.draw.{method_name}() requires a rect or ((x, y), (w, h))") from None
+        if color is None:
+            raise TypeError(f"screen.draw.{method_name}() requires a color")
+        return pygame.Rect(round(l), round(t), round(w), round(h)), (l, t, w, h), color
+
+    def rect(self, rect, color_or_size=None, color=None, width=1):
+        """Draw a rectangle: rect(rect, color) or rect((x, y), (w, h), color)."""
+        rect, (l, t, w, h), color = self._coerce_rect(rect, color_or_size, color, "rect")
+
+        if width <= 1:
+            pygame.draw.rect(self._surf, make_color(color), rect, width)
+            return
+
+        c = make_color(color)
+
+        hw = width / 2
+        l1, l2 = round(l - hw), round(l + hw)
+        r1, r2 = round(l + w - hw), round(l + w + hw)
+        t1, t2 = round(t - hw), round(t + hw)
+        b1, b2 = round(t + h - hw), round(t + h + hw)
+
+        def r(x1, y1, x2, y2):
+            rr = pygame.Rect(x1, y1, x2 - x1, y2 - y1)
+            pygame.draw.rect(self._surf, c, rr, 0)
+
+        r(l1, t1, r2, t2)
+        r(l1, t2, l2, b1)
+        r(r1, t2, r2, b1)
+        r(l1, b1, r2, b2)
+
+    def filled_rect(self, rect, color_or_size=None, color=None):
+        """Draw a filled rectangle: filled_rect(rect, color) or filled_rect((x, y), (w, h), color)."""
+        rect, _, color = self._coerce_rect(rect, color_or_size, color, "filled_rect")
+        pygame.draw.rect(self._surf, make_color(color), rect, 0)
+
+    def text(self, *args, **kwargs):
+        """Draw text to the screen."""
+        # FIXME: expose ptext parameters, for autocompletion and autodoc
+        ptext.draw(*args, surf=self._surf, **kwargs)
+
+    def textbox(self, *args, **kwargs):
+        """Draw text to the screen, wrapped to fit a box"""
+        # FIXME: expose ptext parameters, for autocompletion and autodoc
+        ptext.drawbox(*args, surf=self._surf, **kwargs)
+
+
+def blit_gradient(start, stop, dest_surface):
+    """Blit a gradient into a destination surface.
+
+    The function does not return anything as the gradient is written
+    in-place in the destination surface.
+
+    Args:
+      start: The starting (top) color as a tuple (red, green, blue).
+      stop: The stopping (bottom) color as a tuple (red, green, blue).
+      dest_surface: A pygame.Surface to write the gradient into.
+    Returns:
+      None."""
+    surface_compact = pygame.Surface((2, 2))
+    pixelarray = pygame.PixelArray(surface_compact)
+    pixelarray[0][0] = start
+    pixelarray[0][1] = stop
+    pixelarray[1][0] = start
+    pixelarray[1][1] = stop
+    pygame.transform.smoothscale(
+        surface_compact,
+        pygame.PixelArray(dest_surface).shape,
+        dest_surface=dest_surface,
+    )
+
+
+class Screen:
+    """Interface to the screen."""
+
+    def _set_surface(self, surface):
+        self.surface = surface
+        self.width, self.height = surface.get_size()
+
+    def bounds(self):
+        """Return a Rect representing the bounds of the screen."""
+        return ZRect((0, 0), (self.width, self.height))
+
+    def clear(self):
+        """Clear the screen to black."""
+        self.fill((0, 0, 0))
+
+    def fill(self, color, gcolor=None):
+        """Fill the screen with a colour."""
+        if gcolor:
+            start = make_color(color)
+            stop = make_color(gcolor)
+            blit_gradient(start, stop, self.surface)
+        else:
+            self.surface.fill(make_color(color))
+
+    def blit(self, image, pos):
+        """Draw a sprite onto the screen.
+
+        "blit" is an archaic name for this operation, but one that is is still
+        frequently used, for example in Pygame. See the `Wikipedia article`__
+        for more about the etymology of the term.
+
+        .. __: http://en.wikipedia.org/wiki/Bit_blit
+
+        :param image: A Surface or the name of an image object to load.
+        :param pos: The coordinates at which the top-left corner of the sprite
+                    will be positioned. This may be given as a pair of
+                    coordinates or as a Rect. If a Rect is given the sprite
+                    will be drawn at ``rect.topleft``.
+
+        """
+        if isinstance(image, str):
+            image = loaders.images.load(image)
+        self.surface.blit(image, pos, None, pygame.BLEND_ALPHA_SDL2)
+
+    @property
+    def draw(self):
+        return SurfacePainter(self)
+
+    def __repr__(self):
+        return "<Screen width={} height={}>".format(self.width, self.height)
+
+
+screen_instance = Screen()

pgzero/soundfmt.py

@@ -0,0 +1,105 @@
+"""Identify WAV file formats.
+
+This is used only to give better error messages in the event that a sound
+file is not loadable by Pygame.
+
+This is based on the 'magic' information for the 'file' command, at
+
+https://github.com/file/file/blob/86e34444a26860f2ad9895a2d77cb16d1ca4c48b/magic/Magdir/riff
+
+"""
+
+from struct import unpack_from
+
+
+class MagicReader:
+    """Interface to reading the magic numbers in a file's header."""
+
+    def __init__(self, path):
+        with open(path, 'rb') as f:
+            self.bytes = f.read(64 * 1024)
+
+    def read_bytes(self, offset, length=4):
+        return self.bytes[offset:offset + length]
+
+    def read_leshort(self, offset):
+        """Read an unsigned short at the given offset."""
+        return unpack_from('<H', self.bytes, offset)[0]
+
+    def read_lelong(self, offset):
+        """Read an unsigned long at the given offset."""
+        return unpack_from('<L', self.bytes, offset)[0]
+
+
+CODECS = {
+    1: 'Microsoft PCM',
+    2: 'Microsoft ADPCM',
+    3: 'PCM (float)',
+    6: 'ITU G.711 A-law',
+    7: 'ITU G.711 µ-law',
+    8: 'Microsoft DTS',
+    17: 'IMA ADPCM',
+    20: 'ITU G.723 ADPCM (Yamaha)',
+    34: 'DSP Group Truespeech',
+    49: 'GSM 6.10',
+    64: 'ITU G.721 ADPCM',
+    80: 'MPEG',
+    85: 'MP3',
+    112: 'Lernout & Hauspie CELP',
+    114: 'Lernout & Hauspie SBC',
+    0x2001: 'DTS',
+}
+
+
+def riff_wave(f, offset):
+    """Read the WAVE format information."""
+    encoding = f.read_leshort(offset)
+    yield CODECS.get(encoding, 'unknown encoding %d' % encoding)
+    if encoding in (1, 3):
+        bitrate = f.read_leshort(offset + 14)
+        if 0 < bitrate < 1024:
+            yield '%d bit' % bitrate
+    channels = f.read_leshort(offset + 2)
+    if channels == 1:
+        yield 'mono'
+    elif channels == 2:
+        yield 'stereo'
+    elif 2 < channels < 128:
+        yield '%d channels' % channels
+
+    hz = f.read_lelong(offset + 4)
+    if 0 < hz < 1000000:
+        yield '%d Hz' % hz
+
+
+def riff_walk(f, offset):
+    """Search chunks trying to find b'fmt '"""
+    chunk = f.read_bytes(offset)
+    if chunk == b'fmt ':
+        if f.read_lelong(offset + 4) < 0x80:
+            return list(riff_wave(f, offset + 8))
+    elif chunk[:3] == b'VP8':
+        return ['VP8 encoding']
+    elif chunk in (b'LIST', b'DISP', b'bext', b'Fake', b'fact'):
+        off = f.read_lelong(offset + 4)
+        return riff_walk(f, off + 4)
+    return ["Unknown WAVE encoding"]
+
+
+def identify(path):
+    f = MagicReader(path)
+    if f.read_bytes(0) != b'RIFF':
+        return 'Unknown format (not RIFF WAVE)'
+
+    if f.read_bytes(8) != b'WAVE':
+        return 'Unknown RIFF format (not WAVE)'
+
+    return 'WAV audio encoded as ' + ', '.join(riff_walk(f, 12))
+
+
+if __name__ == '__main__':
+    import sys
+    tabstop = max(len(a) for a in sys.argv[1:]) + 1
+    for path in sys.argv[1:]:
+        sndfmt = identify(path)
+        print(('%s:' % path).ljust(tabstop), sndfmt)