pgzero-plus 0.1.0__py3-none-any.whl

pgzero/animation.py

@@ -0,0 +1,244 @@
+# Easing Functions ported from the Clutter Project via http://kivy.org/
+#  http://www.clutter-project.org/docs/clutter/stable/ClutterAlpha.html
+
+
+from math import sin, pow, pi
+
+from .clock import each_tick, unschedule
+from .spellcheck import suggest
+
+TWEEN_FUNCTIONS = {}
+
+
+def tweener(f):
+    TWEEN_FUNCTIONS[f.__name__] = f
+    return f
+
+
+@tweener
+def linear(n):
+    return n
+
+
+@tweener
+def accelerate(n):
+    return n * n
+
+
+@tweener
+def decelerate(n):
+    return -1.0 * n * (n - 2.0)
+
+
+@tweener
+def accel_decel(n):
+    p = n * 2
+    if p < 1:
+        return 0.5 * p * p
+    p -= 1.0
+    return -0.5 * (p * (p - 2.0) - 1.0)
+
+
+@tweener
+def in_elastic(n):
+    p = .3
+    s = p / 4.0
+    q = n
+    if q == 1:
+        return 1.0
+    q -= 1.0
+    return -(pow(2, 10 * q) * sin((q - s) * (2 * pi) / p))
+
+
+@tweener
+def out_elastic(n):
+    p = .3
+    s = p / 4.0
+    q = n
+    if q == 1:
+        return 1.0
+    return pow(2, -10 * q) * sin((q - s) * (2 * pi) / p) + 1.0
+
+
+@tweener
+def in_out_elastic(n):
+    p = .3 * 1.5
+    s = p / 4.0
+    q = n * 2
+    if q == 2:
+        return 1.0
+    if q < 1:
+        q -= 1.0
+        return -.5 * (pow(2, 10 * q) * sin((q - s) * (2.0 * pi) / p))
+    else:
+        q -= 1.0
+        return pow(2, -10 * q) * sin((q - s) * (2.0 * pi) / p) * .5 + 1.0
+
+
+def _out_bounce_internal(t, d):
+    p = t / d
+    if p < (1.0 / 2.75):
+        return 7.5625 * p * p
+    elif p < (2.0 / 2.75):
+        p -= (1.5 / 2.75)
+        return 7.5625 * p * p + .75
+    elif p < (2.5 / 2.75):
+        p -= (2.25 / 2.75)
+        return 7.5625 * p * p + .9375
+    else:
+        p -= (2.625 / 2.75)
+        return 7.5625 * p * p + .984375
+
+
+def _in_bounce_internal(t, d):
+    return 1.0 - _out_bounce_internal(d - t, d)
+
+
+@tweener
+def bounce_end(n):
+    return _out_bounce_internal(n, 1.)
+
+
+@tweener
+def bounce_start(n):
+    return _in_bounce_internal(n, 1.)
+
+
+@tweener
+def bounce_start_end(n):
+    p = n * 2.
+    if p < 1.:
+        return _in_bounce_internal(p, 1.) * .5
+    return _out_bounce_internal(p - 1., 1.) * .5 + .5
+
+
+def tween(n, start, end):
+    return start + (end - start) * n
+
+
+def tween_attr(n, start, end):
+    if isinstance(start, tuple):
+        return tuple(tween(n, a, b) for a, b in zip(start, end))
+    elif isinstance(start, list):
+        return [tween(n, a, b) for a, b in zip(start, end)]
+    else:
+        return tween(n, start, end)
+
+
+class Animation:
+    """An animation manager for object attribute animations.
+
+    Each keyword argument given to the Animation on creation (except
+    "type" and "duration") will be *tweened* from their current value
+    on the object to the target value specified.
+
+    If the value is a list or tuple, then each value inside that will
+    be tweened.
+
+    The update() method is automatically scheduled with the clock for
+    the duration of the animation.
+
+    """
+    animations = []  # Stores strong references to objects being animated.
+
+    # Animations are stored in _animation_dict under (object id, target
+    # attribute) keys. Objects may not be hashable, so the id, rather than
+    # the object itself, is needed.
+    # Animations with multiple targets will appear here multiple times.
+    # Newly scheduled animations will overwrite new ones. Once an animation
+    # ends, it is removed from this dict.
+    # Note that Animation keeps a reference to "its" object, so the id in the
+    # key will be valid as long as the animation lives.
+    _animation_dict = {}
+
+    def __init__(self, object, tween='linear', duration=1, on_finished=None,
+                 **targets):
+        self.targets = targets
+        try:
+            self.function = TWEEN_FUNCTIONS[tween]
+        except KeyError:
+            suggested_tween = suggest(tween, TWEEN_FUNCTIONS.keys())
+            if len(suggested_tween) > 0:
+                raise KeyError(
+                    'No tween called %s found, did you mean %s?'
+                    % (tween, suggested_tween[0])
+                )
+            else:
+                raise KeyError('No tween called %s found.' % tween)
+        self.duration = duration
+        self.on_finished = on_finished
+        self.t = 0
+        self.object = object
+        self.initial = {}
+        self._running = True
+        for k in self.targets:
+            try:
+                a = getattr(object, k)
+            except AttributeError:
+                raise ValueError(
+                    'object %r has no attribute %s to animate' % (object, k)
+                )
+            self.initial[k] = a
+            key = id(object), k
+            previous_animation = self._animation_dict.get(key)
+            if previous_animation is not None:
+                previous_animation._remove_target(k)
+            self._animation_dict[key] = self
+        each_tick(self.update)
+        self.animations.append(self)
+
+    @property
+    def running(self):
+        """Running state of the animation.
+
+        True if the animation is running.
+        False if the duration has elapsed or the stop() method was called.
+        """
+        return self._running
+
+    def update(self, dt):
+        self.t += dt
+        n = self.t / self.duration
+        if n > 1:
+            n = 1
+            self.stop(complete=True)
+            if self.on_finished is not None:
+                self.on_finished()
+            return
+        n = self.function(n)
+        for k in self.targets:
+            v = tween_attr(n, self.initial[k], self.targets[k])
+            setattr(self.object, k, v)
+
+    def stop(self, complete=False):
+        """Stop the animation, optionally completing the transition to the final
+        property values.
+
+        :param complete: If True, the object will have its targets
+            set to their final values for the animation. If not, the
+            targets will be set to some value between the start and
+            end values.
+        """
+        if not self._running:
+            # Don't do anything if already stopped.
+            return
+
+        self._running = False
+        if complete:
+            for k in self.targets:
+                setattr(self.object, k, self.targets[k])
+        for k in list(self.targets):
+            self._remove_target(k, stop=False)
+        unschedule(self.update)
+        self.animations.remove(self)
+
+    def _remove_target(self, target, stop=True):
+        del self.targets[target]
+        del self._animation_dict[id(self.object), target]
+        if not self.targets and stop:
+            self.stop()
+
+
+def animate(object, tween='linear', duration=1, on_finished=None, **targets):
+    return Animation(object, tween, duration, on_finished=on_finished,
+                     **targets)

pgzero/builtins.py

@@ -0,0 +1,45 @@
+# Expose clock API as a builtin
+from . import clock
+from . import music
+from . import tone
+from .actor import Actor
+from .sprites import Sprite, SpriteActor
+from .storage import storage
+from .keyboard import keyboard
+from .animation import animate
+from .rect import Rect, ZRect
+from .loaders import images, sounds
+from .constants import mouse, keys, keymods
+from .game import Game, exit
+from .tilemaps import load_tile_map_actors
+
+# The actual screen will be installed here
+from .screen import screen_instance as screen
+
+# Global game state object. The runner replaces this with a fresh Game each time a game is run.
+game = Game()
+
+
+__all__ = [
+    "screen",  # graphics output
+    "Actor",
+    "images",
+    "Sprite",
+    "SpriteActor",  # graphics
+    "sounds",
+    "music",
+    "tone",  # sound
+    "clock",
+    "animate",  # timing
+    "Rect",
+    "ZRect",  # geometry
+    "keyboard",
+    "mouse",
+    "keys",
+    "keymods",  # input
+    "storage",  # persistence
+    "Game",
+    "game",
+    "exit",
+    "load_tile_map_actors",
+]

pgzero/clock.py

@@ -0,0 +1,200 @@
+"""Clock/event scheduler.
+
+This is a Pygame implementation of a scheduler inspired by the clock
+classes in Pyglet.
+
+"""
+
+import heapq
+from weakref import ref
+from functools import total_ordering
+from types import MethodType
+
+__all__ = ["Clock", "schedule", "schedule_interval", "unschedule", "clear"]
+
+# This type can't be weakreffed in Python 3.4
+builtin_function_or_method = type(open)
+
+
+def weak_method(method):
+    """Quick weak method ref in case users aren't using Python 3.4"""
+    selfref = ref(method.__self__)
+    funcref = ref(method.__func__)
+
+    def weakref():
+        self = selfref()
+        func = funcref()
+        if self is None or func is None:
+            return None
+        return func.__get__(self)
+
+    return weakref
+
+
+def mkref(o):
+    if isinstance(o, MethodType):
+        return weak_method(o)
+    else:
+        try:
+            return ref(o)
+        except TypeError:
+            if isinstance(o, builtin_function_or_method):
+                return lambda: o
+            raise
+
+
+@total_ordering
+class Event:
+    """An event scheduled for a future time.
+
+    Events are ordered by their scheduled execution time.
+
+    """
+
+    def __init__(self, time, cb, repeat=None):
+        self.time = time
+        self.repeat = repeat
+        self.cb = mkref(cb)
+        self.name = str(cb)
+        self.repeat = repeat
+
+    def __lt__(self, ano):
+        return self.time < ano.time
+
+    def __eq__(self, ano):
+        return self.time == ano.time
+
+    @property
+    def callback(self):
+        return self.cb()
+
+
+class Clock:
+    """A clock used for event scheduling.
+
+    When tick() is called, all events scheduled for before now will be called
+    in order.
+
+    tick() would typically be called from the game loop for the default clock.
+
+    Additional clocks could be created - for example, a game clock that could
+    be suspended in pause screens. Your code must take care of calling tick()
+    or not. You could also run the clock at a different rate if desired, by
+    scaling dt before passing it to tick().
+
+    """
+
+    def __init__(self):
+        self.t = 0
+        self.fired = False
+        self.events = []
+        self._each_tick = []
+
+    def clear(self):
+        """Remove all handlers from this clock."""
+        self.events.clear()
+        self._each_tick.clear()
+
+    def schedule(self, callback, delay):
+        """Schedule callback to be called once, at `delay` seconds from now.
+
+        :param callback: A parameterless callable to be called.
+        :param delay: The delay before the call (in clock time / seconds).
+
+        """
+        heapq.heappush(self.events, Event(self.t + delay, callback, None))
+
+    def schedule_unique(self, callback, delay):
+        """Schedule callback to be called once, at `delay` seconds from now.
+
+        If it was already scheduled, postpone its firing.
+
+        :param callback: A parameterless callable to be called.
+        :param delay: The delay before the call (in clock time / seconds).
+
+        """
+        self.unschedule(callback)
+        self.schedule(callback, delay)
+
+    def schedule_interval(self, callback, delay):
+        """Schedule callback to be called every `delay` seconds.
+
+        The first occurrence will be after `delay` seconds.
+
+        :param callback: A parameterless callable to be called.
+        :param delay: The interval in seconds.
+
+        """
+        heapq.heappush(self.events, Event(self.t + delay, callback, delay))
+
+    def unschedule(self, callback):
+        """Unschedule the given callback.
+
+        If scheduled multiple times all instances will be unscheduled.
+
+        """
+        self.events = [e for e in self.events if e.callback != callback if e.callback is not None]
+        heapq.heapify(self.events)
+        self._each_tick = [e for e in self._each_tick if e() != callback]
+
+    def each_tick(self, callback):
+        """Schedule a callback to be called every tick.
+
+        Unlike the standard scheduler functions, the callable is passed the
+        elapsed clock time since the last call (the same value passed to tick).
+
+        """
+        self._each_tick.append(mkref(callback))
+
+    def _fire_each_tick(self, dt):
+        dead = [None]
+        for r in self._each_tick:
+            cb = r()
+            if cb is not None:
+                self.fired = True
+                try:
+                    cb(dt)
+                except Exception:
+                    import traceback
+
+                    traceback.print_exc()
+                    dead.append(cb)
+        self._each_tick = [e for e in self._each_tick if e() not in dead]
+
+    def tick(self, dt):
+        """Update the clock time and fire all scheduled events.
+
+        :param dt: The elapsed time in seconds.
+
+        """
+        self.fired = False
+        self.t += float(dt)
+        self._fire_each_tick(dt)
+        while self.events and self.events[0].time <= self.t:
+            ev = heapq.heappop(self.events)
+            cb = ev.callback
+            if not cb:
+                continue
+
+            if ev.repeat is not None:
+                self.schedule_interval(cb, ev.repeat)
+
+            self.fired = True
+            try:
+                cb()
+            except Exception:
+                import traceback
+
+                traceback.print_exc()
+                self.unschedule(cb)
+
+
+# One instance of a clock is available by default, to simplify the API
+clock = Clock()
+tick = clock.tick
+schedule = clock.schedule
+schedule_interval = clock.schedule_interval
+schedule_unique = clock.schedule_unique
+unschedule = clock.unschedule
+each_tick = clock.each_tick
+clear = clock.clear

pgzero/constants.py

@@ -0,0 +1,33 @@
+"""Names for constants returned by Pygame."""
+from enum import IntEnum
+import pygame.locals
+
+
+# Event type indicating the end of a music track
+MUSIC_END = 99
+
+
+class mouse(IntEnum):
+    LEFT = 1
+    MIDDLE = 2
+    RIGHT = 3
+    WHEEL_UP = 4
+    WHEEL_DOWN = 5
+
+
+# Use a code generation approach to copy Pygame's key constants out into
+# a Python 3.4 IntEnum, stripping prefixes where possible
+srclines = ["class keys(IntEnum):"]
+for k, v in vars(pygame.locals).items():
+    if k.startswith('K_'):
+        if k[2].isalpha():
+            k = k[2:]
+        srclines.append("    %s = %d" % (k.upper(), v))
+
+srclines.append("class keymods(IntEnum):")
+for k, v in vars(pygame.locals).items():
+    if k.startswith('KMOD_'):
+        srclines.append("    %s = %d" % (k[5:].upper(), v))
+
+exec('\n'.join(srclines), globals())
+del srclines