exp-runtime-player 0.5.0__py3-none-any.whl

exp_runtime/desktop_pause.py

@@ -0,0 +1,105 @@
+"""Shared native system-menu skin for an episode's pause menu."""
+from . import graphics as pygame
+from .fonts import TextStyle
+from .menu import MenuStrings
+from .ui_assets import LayoutBank, Rect, read_ui
+
+
+PAUSE_OPEN_MS = 400
+
+
+def pause_scale(elapsed_ms):
+    """Native system-menu zoom: 0.001 -> 1, UIKit ease-in/out, 400ms."""
+    progress = max(0, min(1, elapsed_ms / PAUSE_OPEN_MS))
+    if progress in (0, 1):
+        return .001 if progress == 0 else 1.
+    # Invert the time axis of cubic-bezier(.42, 0, .58, 1).
+    low, high = 0., 1.
+    for _ in range(20):
+        t = (low + high) / 2
+        x = 3 * (1 - t)**2 * t * .42 + 3 * (1 - t) * t*t * .58 + t**3
+        if x < progress:
+            low = t
+        else:
+            high = t
+    eased = 3 * (1 - t) * t*t + t**3
+    return .001 + .999 * eased
+
+
+def draw_pause_gear(target, art, *, scale=1):
+    image = art.frame(126, 50 if getattr(art, 'gear_pressed', False) else 49)
+    if scale != 1:
+        image = pygame.transform.smoothscale(image, (round(image.get_width() * scale),
+                                                      round(image.get_height() * scale)))
+    target.blit(image, (0, round(408 * scale)))
+
+
+class PauseRenderer:
+    def __init__(self, library, text, art):
+        self.bank = LayoutBank.parse(read_ui(library, 14))
+        self.strings = MenuStrings.load(library)
+        self.text, self.art = text, art
+        self.canvas = pygame.Surface((320, 480), pygame.SRCALPHA).convert_alpha()
+        self.dimmer = self.canvas.copy()
+        self.dimmer.fill((0, 0, 0, 140))
+
+    def label(self, text, rect, name, size, *, center=False):
+        layout = self.text.layout(name, text, rect.width, TextStyle(size, 0, (41, 104, 221)))
+        left, top, right, bottom = layout.ink_bounds
+        x = rect.x + (rect.width - (right - left)) / 2 - left if center else rect.x
+        self.text.draw_layout(self.canvas, name, layout, x,
+                              rect.y + (rect.height - (bottom - top)) / 2 - top)
+
+    def layout(self, index, bounds, *, frames=None):
+        for node, rect in self.bank.walk(index, bounds):
+            if node.kind != 1 or rect.width <= 0 or rect.height <= 0:
+                continue
+            slot, frame = node.payload
+            if frames is not None and frame not in frames:
+                continue
+            image = self.art.frame({0: 126, 3: 16}[slot], frame)
+            self.canvas.blit(pygame.transform.scale(image, (rect.width, rect.height)), (rect.x, rect.y))
+
+    def draw(self, target, *, application=True, main_menu=True, pressed=None,
+             elapsed_ms=PAUSE_OPEN_MS):
+        entries = [(self.strings[21], ('resume',))]
+        if application:
+            entries += [(self.strings[11], ('pause_page', 'options')),
+                        (self.strings[128], ('pause_page', 'help'))]
+        else:
+            # The standalone story viewer has no application settings pages.
+            entries += [('Save', ('save',)), ('Load', ('load',))]
+        if main_menu:
+            entries.append((self.strings[10], ('main_menu',)))
+        # SHSWidgetMenu::solveMetrics centers the system menu in 480 pixels;
+        # UIKit heightForRowAtIndexPath returns 44 for these ordinary rows.
+        header, footer = self.bank.layouts[33].height, self.bank.layouts[36].height
+        top = (480 - header - 44 * len(entries) - footer) // 2
+        self.canvas.fill((0, 0, 0, 0))
+        self.layout(33, Rect(9, top, 302, header))
+        title = self.bank.rectangle(33, 2, Rect(9, top, 302, header))
+        self.label(self.strings[9], title, 'ArialRoundedMTBold28', 28, center=True)
+        buttons = []
+        for index, (label, command) in enumerate(entries):
+            y = top + header + index * 44
+            row = Rect(9, y, 302, 44)
+            # Native table cells occupy the 296px interior. Stretching their
+            # art to the 302px outer box painted over its three-pixel borders.
+            color = ((170, 225, 249, 243) if pressed == command else
+                     (255, 242, 255, 239) if index % 2 else (239, 239, 249, 239))
+            pygame.draw.rect(self.canvas, color, (12, y, 296, 44))
+            edge = self.art.frame(16, 74)
+            for x, source in ((9, 0), (308, 299)):
+                border = edge.subsurface((source, 0, 3, 1))
+                self.canvas.blit(pygame.transform.scale(border, (3, 44)), (x, y))
+            image = self.art.frame(16, 75)
+            self.canvas.blit(pygame.transform.scale(image, (296, 1)), (12, y))
+            self.label(label, Rect(27, y + 3, 266, 38), 'ArialRoundedMTBold14', 14)
+            buttons.append((pygame.Rect(row.x, row.y, row.width, row.height), command))
+        self.layout(36, Rect(9, top + header + 44 * len(entries), 302, footer), frames={74, 79})
+        target.blit(pygame.transform.smoothscale(self.dimmer, target.get_size()), (0, 0))
+        scale = pause_scale(elapsed_ms)
+        size = tuple(max(1, round(length * scale)) for length in target.get_size())
+        image = pygame.transform.smoothscale(self.canvas, size)
+        target.blit(image, image.get_rect(center=target.get_rect().center))
+        return buttons if elapsed_ms >= PAUSE_OPEN_MS else []

exp_runtime/desktop_picker.py

@@ -0,0 +1,68 @@
+"""Original service-78 portrait layout, artwork, and confirmation control."""
+from functools import lru_cache
+
+from . import graphics as pygame
+from .desktop_pause import draw_pause_gear
+
+from .fonts import TextStyle
+from .menu import MenuStrings
+from .ui_assets import Rect, read_ui
+
+
+class CharacterPickerRenderer:
+    def __init__(self, resources, text_renderer, artwork):
+        self.resources, self.text, self.art = resources, text_renderer, artwork
+        self.canvas = pygame.Surface((320, 480)).convert(32)
+        self.hint = None
+
+    @lru_cache(maxsize=32)
+    def portrait(self, asset, theme):
+        # The selector passes the fifth portrait flag as 1: FUN_0009bd40
+        # uses the combined selection ring (43/44), rather than dialogue rings.
+        ring = self.art.frame(126, {1: 43, 2: 44}.get(theme, 0))
+        pieces = [(ring, ring.get_rect(center=(0, 0)))]
+        image = self.art.portrait(asset, False)  # Expression zero, portrait mode 1.
+        if image is not None:
+            pieces.append((image, self.art.portrait_rect(image)))
+        bounds = pieces[0][1].unionall([rect for _, rect in pieces[1:]])
+        layer = pygame.Surface(bounds.size, pygame.SRCALPHA).convert_alpha()
+        for piece, rect in pieces:
+            layer.blit(piece, rect.move(-bounds.x, -bounds.y))
+        return layer, bounds.topleft
+
+    def draw(self, target, session):
+        picker, engine = session.engine.character_picker, session.engine
+        self.canvas.fill((0, 0, 0))
+        self.art.draw_background(self.canvas, engine)
+        theme = engine.numbers.get(engine.number_key(picker.characters[0], 651), 0)
+        # FUN_000d2238/FUN_000d2558 override layout 47's root to this rectangle.
+        self.art.box(self.canvas, Rect(0, 120, 320, 240), theme)
+        for index, character in enumerate(picker.characters):
+            variants = engine.character_art_variants.get(character, [-1])
+            color = engine.numbers.get(engine.number_key(character, 651), 0)
+            layer, (ox, oy) = self.portrait(variants[0], color)
+            motion = picker.portraits[index]
+            x, y, scale = motion.pose
+            layer = pygame.transform.smoothscale(layer, (max(1, round(layer.get_width() * scale)),
+                                                        max(1, round(layer.get_height() * scale))))
+            layer.set_alpha(motion.opacity)
+            self.canvas.blit(layer, (round(x + ox * scale), round(y + oy * scale)))
+        title = self.text.layout('PajamaHip26', session.pending.details['text'], 300,
+                                 TextStyle(16, -16, (255, 255, 255)))
+        self.text.draw_layout(self.canvas, 'PajamaHip26', title, 30, 67.5)
+        self.canvas.blit(self.art.frame(126, 41), (205, 347))
+        self.canvas.blit(self.art.frame(126, 47), (0, 431))
+        draw_pause_gear(self.canvas, self.art)
+        if self.hint is None:
+            self.hint = MenuStrings.load(self.resources.library)[37]
+        hint = self.text.layout('ArialRoundedMTBold11', self.hint,
+                                247, TextStyle(11, 0, (185, 185, 185)))
+        self.text.draw_layout(self.canvas, 'ArialRoundedMTBold11', hint, 63 + (252 - hint.width) / 2, 460)
+        target.blit(pygame.transform.smoothscale(self.canvas, target.get_size()), (0, 0))
+        return [(pygame.Rect(0, 422, 60, 58), ('menu',))]
+
+    @staticmethod
+    def confirm_hit(point):
+        x, y = point
+        # FUN_000d2008: the explicit 50x50 area plus the flipped sprite rectangle.
+        return (210 <= x <= 260 and 330 <= y <= 380) or (205 <= x <= 275 and 344 <= y <= 389)

exp_runtime/desktop_text.py

@@ -0,0 +1,88 @@
+"""Shared atlas drawing for the presentation-independent text layout."""
+from collections import OrderedDict
+from functools import lru_cache
+from io import BytesIO
+from math import floor
+
+from . import graphics as pygame
+
+from .fonts import FontError, layout_text, load_font
+
+
+class BitmapTextRenderer:
+    def __init__(self, library):
+        self.library = library
+        self.fonts = {}
+        self.glyph_images = OrderedDict()
+
+    def font(self, name):
+        if name not in self.fonts:
+            font = load_font(self.library, name)
+            try:
+                if getattr(self.library, 'kind', 'apk') == 'ipa':
+                    from .ios_fonts import render_font
+                    image = render_font(self.library, name)[1]
+                    atlas = pygame.image.frombytes(image.tobytes(), image.size, 'RGBA')
+                else:
+                    atlas = pygame.image.load(BytesIO(self.library.read_ui_asset('fonts/' + font.page)))
+            except pygame.error as error:
+                raise FontError(f'Cannot decode font atlas {font.page}: {error}') from error
+            width, height = atlas.get_size()
+            for glyph in font.glyphs.values():
+                rect = (glyph.x, glyph.y, glyph.width, glyph.height)
+                if any(v != int(v) for v in rect):
+                    raise FontError('Fractional font atlas rectangles are not supported yet')
+                if glyph.x + glyph.width > width or glyph.y + glyph.height > height:
+                    raise FontError(f'Glyph {glyph.code} exceeds actual atlas {font.page}')
+            self.fonts[name] = font, atlas.convert_alpha()
+        return self.fonts[name][0]
+
+    @lru_cache(maxsize=128)
+    def layout(self, name, text, width, style):
+        return layout_text(self.font(name), text, width, style)
+
+    def _glyph_image(self, name, placed, scale):
+        glyph = placed.glyph
+        key = name, glyph.code, placed.color, scale
+        if key not in self.glyph_images:
+            atlas = self.fonts[name][1]
+            image = atlas.subsurface(pygame.Rect(glyph.x, glyph.y, glyph.width, glyph.height)).copy()
+            # Modulate original RGB, retaining colored atlas variants and alpha.
+            image.fill((*placed.color, 255), special_flags=pygame.BLEND_RGBA_MULT)
+            size = max(1, round(glyph.width * scale)), max(1, round(glyph.height * scale))
+            if image.get_size() != size:
+                image = pygame.transform.smoothscale(image, size)
+            self.glyph_images[key] = image
+            if len(self.glyph_images) > 512:
+                self.glyph_images.popitem(last=False)
+        self.glyph_images.move_to_end(key)
+        return self.glyph_images[key]
+
+    def draw(self, surface, name, text, x, y, width, style, *, scale=1):
+        """Draw using the current canvas placement; return the next free Y.
+
+        Normalize only the block's top ink overhang for the provisional desktop
+        panel. Native line positions, offsets, advances and colors stay in the
+        pure layout. Complete native panel anchoring is still being recovered.
+        """
+        if scale <= 0:
+            raise FontError('Font display scale must be positive')
+        layout = self.layout(name, text, width / scale, style)
+        _, top, _, bottom = layout.ink_bounds
+        top = min(0, top)
+        for placed in layout.glyphs:
+            surface.blit(self._glyph_image(name, placed, scale),
+                         (floor(x + placed.x * scale + .5), floor(y + (placed.y - top) * scale + .5)))
+        return y + (max(layout.height, bottom) - top) * scale
+
+    def draw_layout(self, surface, name, layout, x, y, *, scale=1, source_end=None):
+        """Draw a native layout origin without moving its ink overhang."""
+        self.font(name)
+        for placed in layout.glyphs:
+            if source_end is not None and placed.index >= source_end:
+                continue
+            # Half-to-even rounding snaps adjacent glyph bearings in opposite
+            # directions at a half-pixel line origin (notably Continue's i).
+            # Use one translation-invariant pixel rule for the whole line.
+            surface.blit(self._glyph_image(name, placed, scale),
+                         (floor(x + placed.x * scale + .5), floor(y + placed.y * scale + .5)))

exp_runtime/desktop_title.py

@@ -0,0 +1,82 @@
+"""Original episode intros and week cards, drawn from the player's APK."""
+from functools import lru_cache
+
+from . import graphics as pygame
+from .desktop_pause import draw_pause_gear
+
+from .atlas import AtlasFont
+from .content import ContentError
+from .fonts import TextStyle, layout_label
+from .menu import MenuStrings
+from .title_screen import title_labels
+from .ui_assets import Rect, read_ui
+
+
+class TitleRenderer:
+    def __init__(self, resources, text_renderer, artwork):
+        self.resources, self.text, self.art = resources, text_renderer, artwork
+        self.canvas = pygame.Surface((320, 480)).convert(32)
+
+    @lru_cache(maxsize=2)
+    def font(self, asset):
+        image = getattr(self.art, 'ui_image', self.art.image)(asset)
+        if image is None:
+            raise ContentError(f'Title font atlas {asset} is missing')
+        return AtlasFont.parse(read_ui(self.resources, asset + 1), Rect(0, 0, *image.get_size()))
+
+    @lru_cache(maxsize=64)
+    def labels(self, title, subtitle):
+        return title_labels(self.resources.dialogue_layout().bank, self.font(528), self.font(530),
+                            title, subtitle)
+
+    @lru_cache(maxsize=128)
+    def label_image(self, label):
+        font = self.font(label.asset_id)
+        atlas = getattr(self.art, 'ui_image', self.art.image)(label.asset_id)
+        if not label.glyphs:
+            return None, (0, 0)
+        left, top = min(g.x for g in label.glyphs), min(g.y for g in label.glyphs)
+        right = max(g.x + font.glyph(g.character)[2] for g in label.glyphs)
+        bottom = max(g.y + font.height for g in label.glyphs)
+        image = pygame.Surface((max(1, right - left), max(1, bottom - top)), pygame.SRCALPHA).convert_alpha()
+        for g in label.glyphs:
+            x, y, width = font.glyph(g.character)
+            image.blit(atlas, (g.x - left, g.y - top), (x, y, width, font.height))
+        return image, (left, top)
+
+    def draw_label(self, label, scale_y=1.):
+        image, (left, top) = self.label_image(label)
+        if image is None:
+            return
+        sx, sy = label.scale, label.scale * scale_y
+        size = max(1, round(image.get_width() * sx)), max(1, round(image.get_height() * sy))
+        self.canvas.blit(pygame.transform.smoothscale(image, size),
+                         (round(label.origin[0] + left * sx), round(label.origin[1] + top * sy)))
+
+    @lru_cache(maxsize=1)
+    def hint(self):
+        strings = MenuStrings.load(self.resources.library)
+        # 0007cbbc / 0007d4c8: font registry 11, zero content size,
+        # center/center alignment, GL position (180,25), white text.
+        font = self.text.font('ArialMT14')
+        return layout_label(font, strings[36], 0, 0, TextStyle(14, 8), 0x0a)
+
+    def draw(self, target, session):
+        details, motion = session.pending.details, session.engine.title_screen
+        self.canvas.fill((0, 0, 0))
+        background = self.art.image(details['asset_id'])
+        if background is not None and motion.background_alpha > 0:
+            background = pygame.transform.smoothscale(background, (320, 480))
+            background.set_alpha(round(255 * motion.background_alpha))
+            self.canvas.blit(background, (0, 0))
+        title, subtitle = self.labels(details['title'], details['subtitle'])
+        self.canvas.set_clip((0, 0, motion.reveal_width, 480))
+        self.draw_label(title)
+        self.canvas.set_clip(None)
+        self.draw_label(subtitle, motion.subtitle_scale_y)
+        self.canvas.blit(self.art.frame(126, 47), (0, 431))
+        draw_pause_gear(self.canvas, self.art)
+        self.text.draw_layout(self.canvas, 'ArialMT14', self.hint(), 180, 455)
+        target.blit(pygame.transform.smoothscale(self.canvas, target.get_size()), (0, 0))
+        return [(pygame.Rect(0, 422, 60, 58), ('menu',)),
+                (pygame.Rect(0, 0, 320, 480), ('continue',))]

exp_runtime/graphics.py

@@ -0,0 +1,79 @@
+"""Drawing/platform primitives for the shared presentation code.
+
+Desktop uses pygame directly. A mobile host installs its backend before it
+imports the application; menus, panel geometry and event handling stay shared.
+"""
+_backend = None
+
+
+class _MenuMusic:
+    """An SDL channel independent of the paused story's streaming music."""
+    def __init__(self, mixer):
+        self.mixer = mixer
+        self.sound = self.channel = None
+
+    def load(self, stream):
+        self.sound = self.mixer.Sound(file=stream)
+
+    def play(self):
+        self.channel = self.sound.play()
+        if self.channel is None:
+            raise ValueError('No audio channel is available for menu music')
+
+    def stop(self):
+        if self.channel is not None:
+            self.channel.stop()
+        self.sound = self.channel = None
+
+    def pause(self):
+        if self.channel is not None:
+            self.channel.pause()
+
+    def unpause(self):
+        if self.channel is not None:
+            self.channel.unpause()
+
+
+def create_menu_music():
+    mixer = __getattr__('mixer')
+    return mixer.menu_music if hasattr(mixer, 'menu_music') else _MenuMusic(mixer)
+
+
+def project_quad(target, image, points):
+    """Project a sprite with the shared scanline rule, batching on native hosts.
+
+    Board-plane quads have horizontal top/bottom edges. Geometry and rounding
+    stay here; the platform only draws the resulting textured rows.
+    """
+    tl, tr, br, bl = points
+    top, bottom = round(tl[1]), round(bl[1])
+    height = max(1, bottom - top)
+    rows = []
+    for y in range(height):
+        t = (y + .5) / height
+        left = tl[0] + (bl[0] - tl[0]) * t
+        right = tr[0] + (br[0] - tr[0]) * t
+        rows.append((round(left), max(1, round(right - left))))
+    batch = getattr(__getattr__('draw'), 'textured_rows', None)
+    if batch is not None:
+        batch(target, image, top, rows)
+        return
+    transform = __getattr__('transform')
+    source = transform.smoothscale(image, (image.get_width(), height))
+    for y, (left, width) in enumerate(rows):
+        row = source.subsurface((0, y, source.get_width(), 1))
+        target.blit(transform.smoothscale(row, (width, 1)), (left, top + y))
+
+
+def install(backend):
+    global _backend
+    previous, _backend = _backend, backend
+    return previous
+
+
+def __getattr__(name):
+    global _backend
+    if _backend is None:
+        import pygame
+        _backend = pygame
+    return getattr(_backend, name)

exp_runtime/platforms/__init__.py

@@ -0,0 +1 @@
+"""Host adapters. Game behavior and layout live in the shared runtime."""