WTS/game/scripts/chibis/classes.rpy

# Screen used by chibi class (each chibi object derives its own uniquely tagged screen from this one)
screen chibi(chibi_object):
    zorder chibi_object.zorder
    sensitive False
    fixed:
        at chibi_object.transform
        fit_first True
        for d in chibi_object.displayables():
            add d
        # frame: # Debug frame
        #     background "#00ff0055"

screen chibi_emote(emote, chibi_object):
    zorder chibi_object.zorder
    sensitive False
    add f"emo_{emote}":
        at emote_effect
        anchor (0.5, 1.0)
        pos chibi_object.pos
        zoom ChibiRoom.get().scale
        xzoom (-1 if chibi_object.flip else 1)
        if chibi_object.tag in ("genie", "snape"):
            offset (int(75*ChibiRoom.get().scale), int(-200*ChibiRoom.get().scale))
        else:
            offset (int(50*ChibiRoom.get().scale), int(-170*ChibiRoom.get().scale))

label chibi_emote(emote, name):
    python:
        if emote == "hide":
            emote = None
        get_chibi_object(name).emote(emote)
    return

default chibi_moves = {}

init -1 python:
    def update_chibi(name):
        """Update the chibi object for a given character."""
        # TODO: Remove once chibi is ready.
        if "hooch" == name:
            return

        get_chibi_object(name).update()

    def get_chibi_object(name):
        """Get a chibi object by its character's name."""
        name = f"{name}_chibi"
        c = getattr(renpy.store, name, None)
        if c and isinstance(c, Chibi):
            return c
        else:
            raise Exception(f"Chibi object not found. {name}")

    def complete_chibi_moves(**elapsed):
        """Resume old chibi action after (multiple) reduced move calls."""
        q = []
        for chibi, (t, a) in chibi_moves.items():
            et = elapsed.get(chibi, 0)
            t -= et
            q.append((chibi, t, a))

        q.sort(key=lambda x: x[1]) # Sort by time
        pt = 0
        for chibi, t, a in q:
            renpy.pause(t - pt)
            pt += t
            get_chibi_object(chibi).do(a)

        chibi_moves.clear()

    class Chibi(object):
        """ Manages a character's chibi.

            Actions:
            * Represent what a chibi is doing.
            * Determine which transform is applied.
            * Allow layers to be changed to the relevant images (via update callback).

            There are two types of actions, one is used in place and the other while moving.

            Actions are defined in the `actions` dict as a tuple: (special, transform, move_action|loop_time).
            * `special` (bool) specifies whether layer images should come from a folder with the same name as the action.
            This can be useful to prevent repetitive code in update callbacks.
            * `transform` (string) is the name of the transform that is used for this action.
            It will be combined with a base transform.
            * `move_action` (string) if set, it's the action that will be used when the chibi starts moving after the current action.
            It should not be set for move actions.
            * `loop_time` (float) if set, it's the time in seconds for one animation loop of this action. Used to calculate movement time.
            It should only be set for move actions. Set to zero to disable time adjustments.

            Layers:
            A chibi is made up of one or more named layers. These are cleared on update and should be set by a callback function.
            * Layers can be accessed as `chibi_object[key]`.
            * A layer can be set to either a filename or any kind of displayable.
            * When setting an image filename, this class will look for it in `image_path` (or `image_path/action` if the action is special).
            * Adding `~` as a prefix to a filename will ignore the special action folder.
            This can be useful for images that are compatible with multiple actions.
            * Layers are updated whenever the action changes by calling `update_callback`, which is expected to set the layers again.
        """

        actions = {
            None: (False, None, "walk"),
            "walk": (False, "chibi_walk", 0.32),
            "run": (False, "chibi_walk", 0),
            "fly": (True, "chibi_fly", "fly_move"),
            "fly_move": (True, "chibi_fly_move", 0),
            "wand": (True, "chibi_wand", "walk"),
        }

        def __init__(self, tag, layers, update_callback, zorder=3, speed=100, image_path=None, actions=None, places=None):
            self.tag = tag

            # Use a tuple/list to specify the order of layers in a dict
            self.layers_order = layers
            self.layers = dict([(k, None) for k in layers])

            self.update_callback = update_callback

            if image_path:
                self.image_path = image_path
            else:
                self.image_path = f"characters/{tag}/chibis"

            if actions:
                # Override class variable for this instance
                self.actions = dict(Chibi.actions)
                self.actions.update(actions)

            self.zorder = zorder
            self.speed = speed # pixels/sec

            self.pos = (0,0)
            self.flip = False
            self.action = None
            self.action_info = self.resolve_action(None)
            self.special = None
            self.transform = None

            # Define a screen for the chibi
            self.screen_tag = f"{tag}_chibi"
            renpy.define_screen(self.screen_tag, Chibi._screen, tag=self.screen_tag, zorder="chibi_object.zorder")

            # Define a screen for the chibi emote
            self.emote_tag = f"{tag}_chibi_emote"
            renpy.define_screen(self.emote_tag, Chibi._emote_screen, tag=self.emote_tag, zorder="chibi_object.zorder")

        @staticmethod
        def _screen(chibi_object, **kwargs):
            # Emulate a Ren'py `use` statement to derive a chibi screen from the generic one
            renpy.use_screen("chibi", chibi_object, _name=kwargs["_name"], _scope=kwargs["_scope"])

        @staticmethod
        def _emote_screen(emote, chibi_object, **kwargs):
            # Emulate a Ren'py `use` statement to derive a chibi_emote screen from the generic one
            renpy.use_screen("chibi_emote", emote, chibi_object, _name=kwargs["_name"], _scope=kwargs["_scope"])

        def show(self):
            renpy.show_screen(self.screen_tag, chibi_object=self)

        def hide(self):
            renpy.hide_screen(self.screen_tag)
            renpy.hide_screen(self.emote_tag)

        def emote(self, emote=None):
            if renpy.get_screen(self.emote_tag):
                renpy.hide_screen(self.emote_tag)
                renpy.pause(0.2) # Pause for duration of emote_effect
            if emote:
                renpy.show_screen(self.emote_tag, emote=emote, chibi_object=self)

        def update(self):
            self.clear()
            if self.update_callback:
                self.update_callback(self)

        def move(self, path=None, speed=1.0, reduce=False, action=None):
            """ Moves to a certain point or along a path.
                Movement takes into account the action, direction, time and transitions.
                Flipping is not possible mid-path, so the character should always face the same way.
            """
            if isinstance(path, tuple):
                path = [path]

            real_path = [self.pos]
            for x, y in path:
                pos = self.resolve_position(x,y)
                real_path.append(pos)
            path = real_path

            flip = self.pos[0] <= path[-1][0]
            if self.flip != flip:
                self.flip = flip
                self.do(self.action) # Do a flip!
                renpy.with_statement(d3)

            # Resolve the move action
            old_action = self.action
            if action:
                move_action = action
            elif isinstance(self.action_info[2], str):
                # Action info provides a move action
                move_action = self.action_info[2]
            else:
                # Current action is already a move action
                move_action = self.action

            _, trans_name, loop_time = self.resolve_action(move_action)

            # Calculate movement time
            times = []
            for i in range(len(path) - 1):
                dist = math.sqrt((path[i][0] - path[i+1][0])**2 + (path[i][1] - path[i+1][1])**2)
                time = dist / (float(self.speed) * speed)
                if loop_time > 0:
                    # Round to nearest multiple of loop time to end on the right frame
                    time = loop_time * round(time/loop_time)
                times.append(time)

            time = sum(times)

            # Apply the action with a transform
            trans = self.resolve_transform(trans_name, path, times)
            self.do(move_action, trans)
            self.position(*path[-1])

            if reduce:
                # Reduce the pause and don't do the old action
                if reduce == "all":
                    reduce = time
                elif isinstance(reduce, bool):
                    reduce = 0

                time -= float(reduce)
                chibi_moves[self.tag] = (reduce, old_action)

                if time > 0:
                    renpy.pause(time)
            else:
                # Pause while moving and then do the old action
                renpy.pause(time)
                if old_action != move_action:
                    self.do(old_action)
                    renpy.with_statement(None)

        def do(self, action=None, trans=None):
            """Performs an action. Applies a transform and updates the chibi."""
            self.set_action(action)

            # Set the transform (static version by default)
            if trans is None:
                trans = self.resolve_transform(self.action_info[1])

            # Hide the screen so transform is reset properly
            self.hide()
            self.transform = trans
            self.update()
            self.show()

        def set_action(self, action):
            """Set the action state (no screen update)."""
            self.action = action
            self.action_info = self.resolve_action(action)
            self.special = self.action_info[0]

        def position(self, x=None, y=None, flip=None):
            """Set the position to be used on next update."""
            (x,y) = self.resolve_position(x,y)
            if flip is not None:
                self.flip = flip
            self.pos = (x,y)

        def resolve_position(self, x=None, y=None):
            """Compute new position from place keywords (or just ints) for one or both of the coordinates."""
            return ChibiRoom.place((x,y), self.pos)

        def resolve_transform(self, name, *args):
            """Get transform from the store by name and apply arguments."""
            if name:
                trans = getattr(renpy.store, name, None)
                if isinstance(trans, renpy.display.transform.ATLTransform):
                    # Combine with base transform
                    return combine_transforms(self.base_transform(), trans(*args))
                elif config.developer:
                    raise Exception(f"Expected an ATL transform: {name}")
            # No transform was given or found
            return self.base_transform()

        def base_transform(self):
            scale = ChibiRoom.get().scale
            return chibi_base(self.pos, self.flip, scale)

        def resolve_action(self, name):
            """Get action info by name (falling back to "parent" action or default)."""
            while True:
                if name in self.actions:
                    return self.actions[name]
                elif '_' in name:
                    name = name.rsplit('_', 1)[0]
                else:
                    return self.actions[None]

        def displayables(self):
            """Yields non-empty layers in an iterable manner."""
            for k in self.layers_order:
                d = self.layers.get(k, None)
                if d is not None:
                    yield d

        def clear(self):
            for k in self.layers.keys():
                self.layers[k] = None

        def __getitem__(self, key):
            return self.layers[key]

        def __setitem__(self, key, value):
            if key not in self.layers:
                # Layer must be defined at init
                raise KeyError(key)

            if isinstance(value, str) and '.' in value:
                # Assume value is a filename and resolve it
                if value.startswith('~') or not self.special:
                    # Avoid special directory
                    value = self.image_path + "/" + value.lstrip("~/")
                else:
                    value = self.image_path + "/" + self.action + "/" + value

            self.layers[key] = value

    class ChibiRoom(object):
        """Defines chibi scale factor and named positions (places) for a room."""

        # Rooms by name
        rooms = dict()

        def __init__(self, name, scale, places):
            self.name = name
            self.scale = scale
            self.places = places

            ChibiRoom.rooms[self.name] = self

        def resolve(self, p, d, x_or_y):
            """Resolve p as coordinate, if None return d, else return p as integer."""
            if not isinstance(p, int):
                if p is None:
                    return d
                elif p in self.places:
                    return self.places[p][int(x_or_y)] or d
                else:
                    return int(p)
            return p

        @staticmethod
        def get(room=None):
            room = room or renpy.store.states.room
            chibi_room = ChibiRoom.rooms.get(room, None)
            if not chibi_room:
                raise Exception(f"Chibi room is not defined for {room}")
            return chibi_room

        @staticmethod
        def place(place, position, room=None):
            """Resolve place coordinates in the current room, or a given room (by name)."""
            chibi_room = ChibiRoom.get(room)
            # TODO: TEMPORARY FIX FOR SCALING; TO BE REPLACED BY NEW CHIBI IMPLEMENTATION IN THE FUTURE
            x = chibi_room.resolve(place[0], position[0], False) * 2
            y = chibi_room.resolve(place[1], position[1], True) * 2
            return (x,y)