include renpy

1 files changed, 634 insertions, 0 deletions

diff --git a/unrpyc/renpy/display/anim.py b/unrpyc/renpy/display/anim.py
new file mode 100644
index 0000000..de1398a
--- /dev/null
+++ b/unrpyc/renpy/display/anim.py
@@ -0,0 +1,634 @@
+# Copyright 2004-2013 Tom Rothamel <pytom@bishoujo.us>
+#
+# 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.
+
+# This file contains support for state-machine controlled animations.
+
+import renpy.display
+import random
+
+class State(object):
+    """
+    This creates a state that can be used in a SMAnimation.
+    """
+
+
+    def __init__(self, name, image, *atlist, **properties):
+        """
+        @param name: A string giving the name of this state.
+
+        @param image: The displayable that is shown to the user while
+        we are in (entering) this state. For convenience, this can
+        also be a string or tuple, which is interpreted with Image.
+
+        image should be None when this State is used with motion,
+        to indicate that the image will be replaced with the child of
+        the motion.
+
+        @param atlist: A list of functions to call on the image. (In
+        general, if something can be used in an at clause, it can be
+        used here as well.)
+
+        If any keyword arguments are given, they are used to construct a
+        Position object, that modifies the position of the image.
+        """
+
+        if image and not isinstance(image, renpy.display.core.Displayable):
+            image = renpy.easy.displayable(image)
+
+        self.name = name
+        self.image = image
+        self.atlist = atlist
+        self.properties = properties
+
+
+    def add(self, sma):
+        sma.states[self.name] = self
+
+    def get_image(self):
+        rv = self.image
+
+        for i in self.atlist:
+            rv = i(rv)
+
+        if self.properties:
+            rv = renpy.display.layout.Position(rv, **self.properties)
+
+        return rv
+
+    def motion_copy(self, child):
+
+        if self.image is not None:
+            child = self.image
+
+        return State(self.name, child, *self.atlist)
+    
+
+class Edge(object):
+    """
+    This creates an edge that can be used with a SMAnimation.
+    """
+
+    def __init__(self, old, delay, new, trans=None, prob=1):
+        """
+        @param old: The name (a string) of the state that this transition is from.
+
+        @param delay: The number of seconds that this transition takes.
+
+        @param new: The name (a string) of the state that this transition is to.
+
+        @param trans: The transition that will be used to show the
+        image found in the new state. If None, the image is show
+        immediately.
+
+        When used with an SMMotion, the transition should probably be
+        move.
+
+        @param prob: The number of times this edge is added. This can
+        be used to make a transition more probable then others. For
+        example, if one transition out of a state has prob=5, and the
+        other has prob=1, then the one with prob=5 will execute 5/6 of
+        the time, while the one with prob=1 will only occur 1/6 of the
+        time. (Don't make this too large, as memory use is proportional to
+        this value.)
+        """
+
+        self.old = old
+        self.delay = delay
+        self.new = new
+        self.trans = trans
+        self.prob = prob
+
+    def add(self, sma):
+        for _i in range(0, self.prob):
+            sma.edges.setdefault(self.old, []).append(self)
+
+
+class SMAnimation(renpy.display.core.Displayable):
+    """
+    This creates a state-machine animation. Such an animation is
+    created by randomly traversing the edges between states in a
+    defined state machine. Each state corresponds to an image shown to
+    the user, with the edges corresponding to the amount of time an
+    image is shown, and the transition it is shown with.
+
+    Images are shown, perhaps with a transition, when we are
+    transitioning into a state containing that image.
+    """
+    
+    def __init__(self, initial, *args, **properties):
+        """
+        @param initial: The name (a string) of the initial state we
+        start in.
+
+        @param showold: If the keyword parameter showold is True, then
+        the old image is shown instead of the new image when in an
+        edge.
+
+        @param anim_timebase: If True, we use the animation
+        timebase. If False, we use the displayable timebase.
+
+        This accepts as additional arguments the anim.State and
+        anim.Edge objects that are used to make up this state
+        machine.
+        """
+
+        if 'delay' in properties:
+            self.delay = properties['delay']
+            del properties['delay']
+        else:
+            self.delay = None
+
+        if 'showold' in properties:
+            self.showold = properties['showold']
+            del properties['showold']
+        else:
+            self.showold = False
+
+        if 'anim_timebase' in properties:
+            self.anim_timebase = properties['anim_timebase']
+            del properties['anim_timebase']
+        else:
+            self.anim_timebase = True
+
+        super(SMAnimation, self).__init__(**properties)
+
+        self.properties = properties
+
+        # The initial state.
+        self.initial = initial
+
+        # A map from state name to State object.
+        self.states = { }
+
+        # A map from state name to list of Edge objects.
+        self.edges = { }
+
+        for i in args:
+            i.add(self)
+
+        # The time at which the current edge started. If None, will be
+        # set to st by render.
+        self.edge_start = None
+
+        # A cache for what the current edge looks like when rendered.
+        self.edge_cache = None
+
+        # The current edge.
+        self.edge = None
+
+        # The state we're in.
+        self.state = None
+
+    def visit(self):
+        return [ i.image for i in self.states.values() ]
+
+    def pick_edge(self, state):
+        """
+        This randomly picks an edge out of the given state, if
+        one exists. It updates self.edge if a transition has
+        been selected, or returns None if none can be found. It also
+        updates self.image to be the new image on the selected edge.
+        """
+
+        if state not in self.edges:
+            self.edge = None
+            return
+
+        edges = self.edges[state]
+        self.edge = random.choice(edges)
+        self.state = self.edge.new
+        
+    def update_cache(self):
+        """
+        Places the correct Displayable into the edge cache, based on
+        what is contained in the given edge. This takes into account
+        the old and new states, and any transition that is present.
+        """
+
+
+        if self.edge.trans:
+            im = self.edge.trans(old_widget=self.states[self.edge.old].get_image(),
+                                 new_widget=self.states[self.edge.new].get_image())
+        elif self.showold:
+            im = self.states[self.edge.old].get_image()
+        else:
+            im = self.states[self.edge.new].get_image()
+
+        self.edge_cache = im
+
+    def get_placement(self):
+
+        if self.edge_cache:
+            return self.edge_cache.get_placement()
+
+        if self.state:
+            return self.states[self.state].get_image().get_placement()
+
+        return super(SMAnimation, self).get_placement()
+
+    def render(self, width, height, st, at):
+
+        if self.anim_timebase:
+            t = at
+        else:
+            t = st
+
+        if self.edge_start is None or t < self.edge_start:
+            self.edge_start = t
+            self.edge_cache = None
+            self.pick_edge(self.initial)
+
+        while self.edge and t > self.edge_start + self.edge.delay:
+            self.edge_start += self.edge.delay
+            self.edge_cache = None
+            self.pick_edge(self.edge.new)
+
+        # If edge is None, then we have a permanent, static picture. Deal
+        # with that.
+
+        if not self.edge:
+            im = renpy.display.render.render(self.states[self.state].get_image(),
+                                             width, height,
+                                             st - self.edge_start, at)
+
+
+        # Otherwise, we have another edge.
+
+        else:
+            if not self.edge_cache:
+                self.update_cache()
+
+            im = renpy.display.render.render(self.edge_cache, width, height, t - self.edge_start, at)
+
+            if not renpy.game.less_updates:
+                renpy.display.render.redraw(self.edge_cache, self.edge.delay - (t - self.edge_start))
+
+
+        iw, ih = im.get_size()
+
+        rv = renpy.display.render.Render(iw, ih)
+        rv.blit(im, (0, 0))
+
+        return rv
+    
+    def __call__(self, child=None, new_widget=None, old_widget=None):
+        """
+        Used when this SMAnimation is used as a SMMotion. This creates
+        a duplicate of the animation, with all states containing None
+        as the image having that None replaced with the image that is provided here.
+        """
+
+        if child is None:
+            child = new_widget
+
+        args = [ ]
+
+        for state in self.states.values():
+            args.append(state.motion_copy(child))
+
+        for edges in self.edges.values():
+            args.extend(edges)
+
+        return SMAnimation(self.initial, delay=self.delay, *args, **self.properties)
+
+
+# class Animation(renpy.display.core.Displayable):
+#     """
+#     A Displayable that draws an animation, which is a series of images
+#     that are displayed with time delays between them.
+#     """
+
+#     def __init__(self, *args, **properties):
+#         """
+#         Odd (first, third, fifth, etc.) arguments to Animation are
+#         interpreted as image filenames, while even arguments are the
+#         time to delay between each image. If the number of arguments
+#         is odd, the animation will stop with the last image (well,
+#         actually delay for a year before looping). Otherwise, the
+#         animation will restart after the final delay time.
+
+#         @param anim_timebase: If True, the default, use the animation
+#         timebase. Otherwise, use the displayable timebase.
+#         """
+
+#         properties.setdefault('style', 'animation')
+#         self.anim_timebase = properties.pop('anim_timebase', True)
+
+#         super(Animation, self).__init__(**properties)
+
+#         self.images = [ ]
+#         self.delays = [ ]
+
+#         for i, arg in enumerate(args):
+
+#             if i % 2 == 0:
+#                 self.images.append(renpy.easy.displayable(arg))
+#             else:
+#                 self.delays.append(arg)
+
+#         if len(self.images) > len(self.delays):
+#             self.delays.append(365.25 * 86400.0) # One year, give or take.
+                
+#     def render(self, width, height, st, at):
+
+#         if self.anim_timebase:
+#             t = at % sum(self.delays)
+#         else:
+#             t = st % sum(self.delays)
+
+#         for image, delay in zip(self.images, self.delays):
+#             if t < delay:
+#                 renpy.display.render.redraw(self, delay - t)
+
+#                 im = renpy.display.render.render(image, width, height, t, at)
+#                 width, height = im.get_size()
+#                 rv = renpy.display.render.Render(width, height)
+#                 rv.blit(im, (0, 0))
+
+#                 return rv
+            
+#             else:
+#                 t = t - delay
+
+#     def visit(self):
+#         return self.images
+
+def Animation(*args, **kwargs):
+    newargs = [ ]
+
+    for i, a in enumerate(args):
+        newargs.append(a)
+        if i % 2 == 1:
+            newargs.append(None)
+
+    return TransitionAnimation(*newargs, **kwargs)
+    
+
+class TransitionAnimation(renpy.display.core.Displayable):
+    """
+    A displayable that draws an animation with each frame separated
+    by a transition.
+    """
+
+    def __init__(self, *args, **properties):
+        """
+        This takes arguments such that the 1st, 4th, 7th, ...
+        arguments are displayables, the 2nd, 5th, 8th, ... on arguments
+        are times, and the 3rd, 6th, 9th, ... are transitions.
+
+        This displays the first displayable for the given time, then
+        transitions to the second displayable using the given
+        transition, and shows it for the given time (the time of the
+        transition is taken out of the time the frame is shown), and
+        so on.
+
+        The last argument may be a displayable (in which case that
+        displayable is used to transition back to the first frame), or
+        a displayable (which is shown forever).
+
+        There is one keyword argument, apart from the style properties:
+        
+        @param anim_timebase: If True, the default, use the animation
+        timebase. Otherwise, use the displayable timebase.
+        """
+
+        properties.setdefault('style', 'animation')
+        self.anim_timebase = properties.pop('anim_timebase', True)
+
+        super(TransitionAnimation, self).__init__(**properties)
+
+        images = [ ]
+        delays = [ ]
+        transitions = [ ]
+        
+        for i, arg in enumerate(args):
+
+            if i % 3 == 0:
+                images.append(renpy.easy.displayable(arg))
+            elif i % 3 == 1:
+                delays.append(arg)
+            else:
+                transitions.append(arg)
+
+        if len(images) > len(delays):
+            delays.append(365.25 * 86400.0) # One year, give or take.
+        if len(images) > len(transitions):
+            transitions.append(None)
+
+        self.images = images
+        self.prev_images = [ images[-1] ] + images[:-1]
+        self.delays = delays
+        self.transitions = [ transitions[-1] ] + transitions[:-1]
+            
+            
+    def render(self, width, height, st, at):
+
+        if self.anim_timebase:
+            orig_t = at
+        else:
+            orig_t = st
+
+        t = orig_t % sum(self.delays)
+            
+        for image, prev, delay, trans in zip(self.images, self.prev_images, self.delays, self.transitions):
+            if t < delay:
+                if not renpy.game.less_updates:
+                    renpy.display.render.redraw(self, delay - t)
+
+                if trans and orig_t >= self.delays[0]:
+                    image = trans(old_widget=prev, new_widget=image)
+                
+                im = renpy.display.render.render(image, width, height, t, at)
+                width, height = im.get_size()
+                rv = renpy.display.render.Render(width, height)
+                rv.blit(im, (0, 0))
+
+                return rv
+            
+            else:
+                t = t - delay
+
+    def visit(self):
+        return self.images
+
+class Blink(renpy.display.core.Displayable):
+    """
+    """
+
+    def __init__(self, image, on=0.5, off=0.5, rise=0.5, set=0.5, #@ReservedAssignment
+                 high=1.0, low=0.0, offset=0.0, anim_timebase=False, **properties):
+
+        """
+        This takes as an argument an image or widget, and blinks that image
+        by varying its alpha. The sequence of phases is
+        on - set - off - rise - on - ... All times are given in seconds, all
+        alphas are fractions between 0 and 1.
+
+        @param image: The image or widget that will be blinked.
+
+        @param on: The amount of time the widget spends on, at high alpha.
+
+        @param off: The amount of time the widget spends off, at low alpha.
+
+        @param rise: The amount time the widget takes to ramp from low to high alpha.
+
+        @param set: The amount of time the widget takes to ram from high to low.
+
+        @param high: The high alpha.
+
+        @param low: The low alpha.
+
+        @param offset: A time offset, in seconds. Use this to have a
+        blink that does not start at the start of the on phase.
+
+        @param anim_timebase: If True, use the animation timebase, if false, the displayable timebase.
+        """
+        
+        super(Blink, self).__init__(**properties)
+
+        self.image = renpy.easy.displayable(image)
+        self.on = on
+        self.off = off
+        self.rise = rise
+        self.set = set
+        self.high = high
+        self.low = low
+        self.offset = offset
+        self.anim_timebase = anim_timebase
+
+        self.cycle = on + set + off + rise
+
+
+    def visit(self):
+        return [ self.image ]
+
+    def render(self, height, width, st, at):
+
+        if self.anim_timebase:
+            t = at
+        else:
+            t = st
+
+        time = (self.offset + t) % self.cycle
+        alpha = self.high
+
+        if 0 <= time < self.on:
+            delay = self.on - time
+            alpha = self.high
+
+        time -= self.on
+
+        if 0 <= time < self.set:
+            delay = 0            
+            frac = time / self.set
+            alpha = self.low * frac + self.high * (1.0 - frac)
+
+        time -= self.set
+
+        if 0 <= time < self.off:
+            delay = self.off - time
+            alpha = self.low
+
+        time -= self.off
+
+        if 0 <= time < self.rise:
+            delay = 0
+            frac = time / self.rise 
+            alpha = self.high * frac + self.low * (1.0 - frac)
+
+
+        rend = renpy.display.render.render(self.image, height, width, st, at)
+        w, h = rend.get_size()
+        rv = renpy.display.render.Render(w, h)
+
+        rv.blit(rend, (0, 0))
+        rv.alpha = alpha
+        
+        if not renpy.game.less_updates:
+            renpy.display.render.redraw(self, delay)
+
+        return rv
+
+
+
+def Filmstrip(image, framesize, gridsize, delay, frames=None, loop=True, **properties):
+    """
+    This creates an animation from a single image. This image
+    must consist of a grid of frames, with the number of columns and
+    rows in the grid being taken from gridsize, and the size of each
+    frame in the grid being taken from framesize. This takes frames
+    and sticks them into an Animation, with the given delay between
+    each frame. The frames are taken by going from left-to-right
+    across the first row, left-to-right across the second row, and
+    so on until all frames are consumed, or a specified number of
+    frames are taken.
+
+    @param image: The image that the frames must be taken from.
+
+    @param framesize: A (width, height) tuple giving the size of
+    each of the frames in the animation.
+
+    @param gridsize: A (columns, rows) tuple giving the number of
+    columns and rows in the grid.
+
+    @param delay: The delay, in seconds, between frames.
+
+    @param frames: The number of frames in this animation. If None,
+    then this defaults to colums * rows frames, that is, taking
+    every frame in the grid.
+
+    @param loop: If True, loop at the end of the animation. If False,
+    this performs the animation once, and then stops.
+
+    Other keyword arguments are as for anim.SMAnimation.
+    """
+
+    width, height = framesize
+    cols, rows = gridsize
+
+    if frames is None:
+        frames = cols * rows
+
+    i = 0
+
+    # Arguments to Animation
+    args = [ ]
+
+    for r in range(0, rows):
+        for c in range(0, cols):
+
+            x = c * width
+            y = r * height
+
+            args.append(renpy.display.im.Crop(image, x, y, width, height))
+            args.append(delay)
+
+            i += 1
+            if i == frames:
+                break
+
+        if i == frames:
+            break
+            
+    if not loop:
+        args.pop()
+
+    return Animation(*args, **properties)