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

exp_runtime/desktop_choice.py

@@ -0,0 +1,202 @@
+"""Original choice-panel artwork; selection values remain in the session."""
+import math
+from functools import lru_cache
+
+from . import graphics as pygame
+from .desktop_pause import draw_pause_gear
+
+from .choice import BODY_FONT, FOOTER_FONT, ChoiceLayout
+from .choice_hints import preview_choices
+from .fonts import TextStyle
+from .ui_assets import Rect
+
+
+class ChoiceRenderer:
+    def __init__(self, resources, text_renderer, artwork):
+        self.resources, self.text, self.art = resources, text_renderer, artwork
+        self.layout = None
+        self.canvas = pygame.Surface((320, 480)).convert(32)
+        self.cached_key = self.cached_page = None
+        self.hint_key = None
+        self.hints = ()
+        self.viewport = pygame.Rect(0, 0, 320, 421)
+
+    def page(self, session):
+        details = session.pending.details
+        game = session.engine.word_game
+        key = id(session), session.scene, session.vm.steps_executed, game.round if game else None
+        if game:
+            details = dict(details, options=game.options, enabled=[True] * 4, minigame=True)
+        if key != self.cached_key:
+            if self.layout is None:
+                self.layout = ChoiceLayout(self.resources)
+            character = details['character_id']
+            theme = session.engine.numbers.get(session.engine.number_key(character, 651), 0)
+            variants = session.engine.character_art_variants.get(character, ())
+            self.cached_page = self.layout.page(details, theme=theme,
+                                               has_portrait=character >= 0 and bool(variants) and variants[0] > 0)
+            self.cached_key = key
+        return self.cached_page
+
+    @lru_cache(maxsize=8)
+    def timer_panel(self, theme, width, height):
+        layer = pygame.Surface((width, height), pygame.SRCALPHA).convert_alpha()
+        bank = self.layout.bank
+        hidden_until = 0
+        for number, (node, rect) in enumerate(bank.walk(22, Rect(0, 0, width, height)), 1):
+            if number <= hidden_until:
+                continue
+            # 000d9038 hides the score capsule (root 13) for ordinary choices.
+            visible = node.flags & 16 and number != 13
+            if node.kind == 7 and not visible:
+                hidden_until = number + sum(1 for _ in bank.walk(node.payload[0]))
+                continue
+            if node.kind == 1 and visible and rect.width > 0 and rect.height > 0:
+                slot, frame = node.payload
+                pack = {1: 204, 2: 220, 3: 252}.get(theme, 236)
+                image = self.art.frame({0: 126, 2: pack}[slot], frame)
+                layer.blit(pygame.transform.scale(image, (rect.width, rect.height)), (rect.x, rect.y))
+        return layer
+
+    def draw_timer(self, position, elapsed_fraction):
+        """00082744: base 708, then 709 swept clockwise from twelve o'clock."""
+        fraction = min(1., max(0., elapsed_fraction))
+        if getattr(getattr(self.resources, 'library', None), 'kind', 'apk') == 'ipa':
+            # GameModel::init passes common frames 7..22 to the native iOS
+            # circle layer. Each wedge fades over its own 1/16 interval,
+            # holding opacity .8 for the first .4 of that interval.
+            for index in range(16):
+                progress = fraction * 16 - index
+                opacity = min(1., max(0., (1 - progress) / .6)) * .8
+                if opacity <= 0:
+                    continue
+                image = self.art.frame(126, 7 + index).copy()
+                quadrant = index // 4
+                x = 25 - image.get_width() if quadrant >= 2 else 25
+                y = 25 - image.get_height() if quadrant in (0, 3) else 25
+                image.set_alpha(round(opacity * 255))
+                self.canvas.blit(image, (position[0] + 6 + x, position[1] + 5 + y))
+            return
+        self.canvas.blit(self.art.frame(708, 0), position)
+        if fraction <= 0:
+            return
+        timer = self.art.frame(709, 0).copy()
+        if fraction < 1:
+            mask = pygame.Surface(timer.get_size(), pygame.SRCALPHA)
+            cx, cy = timer.get_width() / 2, timer.get_height() / 2
+            radius = math.hypot(cx, cy) + 1
+            points = [(cx, cy)] + [(cx + radius * math.sin(t), cy - radius * math.cos(t))
+                                  for t in (fraction * 2 * math.pi * i / 120 for i in range(121))]
+            pygame.draw.polygon(mask, (255, 255, 255, 255), points)
+            timer.blit(mask, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)
+        self.canvas.blit(timer, position)
+
+    def draw(self, target, session, *, scroll=0, pointer=None, pressed=None, choice_hints=False):
+        page = self.page(session)
+        if choice_hints and self.hint_key != self.cached_key:
+            self.hints = preview_choices(session)
+            self.hint_key = self.cached_key
+        scroll = min(page.max_scroll, max(0, scroll))
+        self.viewport.height = page.timer_panel.y if page.timer_panel else 421
+        self.canvas.set_clip(None)
+        self.canvas.fill((0, 0, 0))
+        if session.engine.word_game:
+            # The word game's separate background is centered at GL (160,240).
+            background = self.art.image(session.engine.panel.background_id)
+            if background is not None:
+                self.canvas.blit(background, background.get_rect(center=(160, 240)))
+        else:
+            self.art.draw_background(self.canvas, session.engine)
+        self.canvas.set_clip(self.viewport)
+        box = page.box
+        body_height = box.height - page.timer_panel.height + 10 if page.timer_panel else box.height
+        self.art.box(self.canvas, Rect(box.x + 10, box.y + 10 - scroll,
+                                       box.width - 20, body_height - 20), page.theme, alpha=243)
+        buttons = []
+        for row in page.rows:
+            rect = pygame.Rect(row.rect.x, row.rect.y - scroll, row.rect.width, row.rect.height)
+            hit = rect.clip(self.viewport)
+            hint = (self.hints[row.index].kind if choice_hints and row.enabled
+                    and self.hint_key == self.cached_key and row.index < len(self.hints) else 'unknown')
+            color = {'gain': (189, 237, 199), 'loss': (251, 201, 199),
+                     'no_gain': (251, 201, 199), 'mixed': (251, 228, 175)}.get(hint)
+            if color is not None:
+                pygame.draw.rect(self.canvas, color, rect)
+            if row.enabled and (pressed == ('choose', row.index)
+                                or pointer is not None and hit.collidepoint(pointer)):
+                color = (tuple(round(channel * .9) for channel in color) + (255,) if color else
+                         (250, 214, 211, 180) if page.theme == 2 else (170, 225, 249, 180))
+                highlight = pygame.Surface(rect.size, pygame.SRCALPHA)
+                highlight.fill(color)
+                self.canvas.blit(highlight, rect)
+            pygame.draw.line(self.canvas, (178, 179, 179), rect.topleft, (rect.right - 1, rect.top))
+            game = session.engine.word_game
+            offset = 0
+            if game and game.animation_ms:
+                offset = (game.animation_ms / 200) * (-210 if row.index % 2 == 0 else 410)
+            self.canvas.set_clip(hit)
+            self.text.draw_layout(self.canvas, BODY_FONT, row.text, row.origin[0] + offset, row.origin[1] - scroll)
+            self.canvas.set_clip(self.viewport)
+            if row.enabled and hit.height:
+                buttons.append((hit, ('choose', row.index)))
+        if page.rows:
+            rect = page.rows[-1].rect
+            y = rect.y + rect.height - scroll
+            pygame.draw.line(self.canvas, (178, 179, 179), (rect.x, y), (rect.x + rect.width - 1, y))
+
+        if page.portrait is not None:
+            cx, cy = page.portrait.center
+            cy -= scroll
+            for index in (37, {1: 38, 2: 39}.get(page.theme, 40)):
+                image = self.art.frame(126, index)
+                self.canvas.blit(image, image.get_rect(center=(cx, cy)))
+            details = session.pending.details
+            asset = session.engine.character_art_variants[details['character_id']][0]
+            # FUN_000ae5d4 requests expression zero, independently of dialogue.
+            image = self.art.portrait(asset, details['portrait_mode'] == 2 and page.theme != 3)
+            if image is not None:
+                self.canvas.blit(image, self.art.portrait_rect(image, (cx, cy)))
+        self.text.draw_layout(self.canvas, page.title_font, page.title,
+                              page.title_origin[0], page.title_origin[1] - scroll)
+        self.text.draw_layout(self.canvas, BODY_FONT, page.description,
+                              page.description_origin[0], page.description_origin[1] - scroll)
+        self.canvas.set_clip(None)
+        if page.timer_panel is not None:
+            panel = page.timer_panel
+            self.canvas.blit(self.timer_panel(page.theme, panel.width, panel.height), (panel.x, panel.y))
+            clock = self.layout.bank.rectangle(22, 10, panel)
+            self.draw_timer((clock.x, clock.y),
+                            1 - session.remaining_ms / session.pending.details['timeout_ms'])
+        game = session.engine.word_game
+        if game:
+            pack = {1: 204, 2: 220, 3: 252}.get(page.theme, 236)
+            self.canvas.blit(self.art.frame(pack, 9), (130, 353))
+            self.canvas.blit(self.art.frame(pack, 10), (182, 375))
+            self.canvas.blit(pygame.transform.scale(self.art.frame(pack, 11), (12, 39)), (221, 375))
+            self.canvas.blit(self.art.frame(pack, 12), (233, 375))
+            self.draw_timer((130, 353), 1 - game.remaining_ms / game.duration_ms)
+            # Native score text is at (230,88) in GL coordinates (top y=392).
+            score = self.text.layout(BODY_FONT, str(game.score), 60, TextStyle(14, 0, (255, 255, 255)))
+            self.text.draw_layout(self.canvas, BODY_FONT, score, 230 - score.width / 2, 392)
+            if game.animation_ms and game.last_delta:
+                color = (37, 147, 56) if game.last_delta > 0 else (255, 0, 0)
+                delta = self.text.layout(BODY_FONT, f'{game.last_delta:+d}', 40, TextStyle(14, 0, color))
+                self.text.draw_layout(self.canvas, BODY_FONT, delta, 275, 365 + game.animation_ms / 10)
+        self.canvas.blit(self.art.frame(126, 47), (0, 431))
+        draw_pause_gear(self.canvas, self.art)
+        hint = 'Touch the best choice'
+        style = TextStyle(11, 0, (185, 185, 185))
+        footer = self.text.layout(FOOTER_FONT, hint, 246, style)
+        self.text.draw_layout(self.canvas, FOOTER_FONT, footer, 63 + (252 - footer.width) / 2, 460)
+        if page.max_scroll:
+            # A desktop affordance for unusually long options; no choices are
+            # discarded or mapped to a different script-visible index.
+            track = pygame.Rect(310, 40, 3, self.viewport.height - 43)
+            pygame.draw.rect(self.canvas, (100, 100, 100), track)
+            visible_height = self.viewport.height - 31
+            thumb = max(20, int(track.height * visible_height / (visible_height + page.max_scroll)))
+            y = track.y + int((track.height - thumb) * scroll / page.max_scroll)
+            pygame.draw.rect(self.canvas, (225, 225, 225), (track.x, y, track.width, thumb))
+        buttons.append((pygame.Rect(0, 422, 60, 58), ('menu',)))
+        target.blit(pygame.transform.smoothscale(self.canvas, target.get_size()), (0, 0))
+        return page, buttons

exp_runtime/desktop_dialogue.py

@@ -0,0 +1,271 @@
+"""Original dialogue artwork at native logical coordinates."""
+from functools import lru_cache
+from io import BytesIO
+
+from . import graphics as pygame
+
+from .content import ContentError
+from .dialogue_notice import NOTICE_FONT, NOTICE_STYLE, NoticeMotion
+from .fonts import TextStyle
+from .menu import MenuStrings
+from .ui_assets import ImagePack, Raster, UIAssetError, read_ui
+
+
+class DialogueRenderer:
+    def __init__(self, resources, text_renderer, image_loader):
+        self.resources = resources
+        self.text = text_renderer
+        self.image = image_loader
+        self.canvas = pygame.Surface((320, 480)).convert(32)
+        self.cached_key = None
+        self.cached_page = None
+        self.name_layer = pygame.Surface((320, 480), pygame.SRCALPHA).convert_alpha()
+
+    def draw_background(self, target, engine):
+        background = self.image(engine.panel.background_id)
+        if background is not None:
+            target.blit(background, engine.background_pan.origin(*background.get_size()))
+
+    @lru_cache(maxsize=8)
+    def pack(self, asset_id):
+        return ImagePack.parse(read_ui(self.resources, asset_id))
+
+    @lru_cache(maxsize=32)
+    def ui_image(self, role):
+        library = getattr(self.resources, 'library', self.resources)
+        if getattr(library, 'kind', 'apk') != 'ipa':
+            return self.image(role)
+        data = read_ui(self.resources, role)
+        if data.startswith((b'\x89PNG', b'\xff\xd8')):
+            return pygame.image.load(BytesIO(data)).convert_alpha()
+        frame = ImagePack.parse(data).images[0]
+        return pygame.image.frombytes(frame.pixels, (frame.width, frame.height), frame.mode).convert_alpha()
+
+    @lru_cache(maxsize=64)
+    def frame(self, asset_id, index):
+        frame = self.pack(asset_id).images[index]
+        return pygame.image.frombytes(frame.pixels, (frame.width, frame.height), frame.mode).convert_alpha()
+
+    @lru_cache(maxsize=32)
+    def portrait(self, asset_id, flipped):
+        """Native portrait texture: normalize, mask, remove 12 rows, then flip."""
+        image = self.image(asset_id)
+        if image is None:
+            return None
+        raster = Raster(*image.get_size(), pygame.image.tobytes(image, 'RGBA'))
+        mask = self.pack(268).images[0]
+        masked = raster.normalize_portrait(mask).portrait_mask(mask)
+        # FUN_0005afbc shortens the masked texture before FUN_0009c034
+        # aligns its bottom to the circle. Keeping the discarded rows lifts
+        # the visible character by 12 pixels inside its frame.
+        height = masked.height - 12
+        if height <= 0:
+            raise UIAssetError(f'Portrait height {masked.height} cannot accommodate the native 12-row crop')
+        pixels = masked.pixels[:masked.width * height * 4]
+        # Match the display format after creating the masked RGBA buffer.
+        # Cocoa's opaque BGRA canvas can otherwise copy transparent RGB
+        # instead of blending it, exposing white pixels and black mask corners.
+        image = pygame.image.frombytes(pixels, (masked.width, height), 'RGBA').convert_alpha()
+        return pygame.transform.flip(image, flipped, False) if flipped else image
+
+    def portrait_rect(self, image, center=(0, 0)):
+        """FUN_0009c034 positions the sprite center within the bubble."""
+        x, y = center
+        offset = self.frame(126, 39).get_height() // 2 - image.get_height() // 2
+        # The native routine halves each height separately. A midbottom
+        # anchor puts odd-height artwork one pixel above this center.
+        return image.get_rect(center=(x, y + offset))
+
+    def box(self, target, rect, theme, *, alpha=255):
+        """FUN_00081920 places the eight border pieces outside the center."""
+        pack = {1: 204, 2: 220, 3: 252}.get(theme, 236)
+        x, y, width, height = rect.x, rect.y, rect.width, rect.height
+        center = self.frame(126, 0).copy()
+        center.set_alpha(alpha)
+        target.blit(pygame.transform.scale(center, (width, height)), (x, y))
+        for index, column, row in ((6, 0, 0), (7, 1, 0), (8, 2, 0), (4, 0, 1),
+                                   (5, 2, 1), (0, 0, 2), (1, 1, 2), (2, 2, 2)):
+            image = self.frame(pack, index).copy()
+            image.set_alpha(alpha)
+            w, h = image.get_size()
+            size = (width if column == 1 else w, height if row == 1 else h)
+            position = (x - w if column == 0 else x + width if column == 2 else x,
+                        y - h if row == 0 else y + height if row == 2 else y)
+            target.blit(pygame.transform.scale(image, size), position)
+
+    @lru_cache(maxsize=32)
+    def portrait_group(self, portrait, clip=None, old=None, old_alpha=0, alpha=255):
+        """The art and both rings are children of the native scaled node."""
+        rings = [self.frame(126, index)
+                 for index in (37, {1: 38, 2: 39}.get(portrait.theme, 40))]
+        if clip is not None:
+            # drawInContext's even-odd path cuts only housing frame 37.
+            # Its polygon has 10px bevels at the two upper corners.
+            housing = rings[0].copy()
+            origin = housing.get_rect(center=(0, 0))
+            x, y, w, h = clip
+            x, y = x - origin.x, y - origin.y
+            pygame.draw.polygon(housing, (0, 0, 0, 0),
+                                ((x, y + h), (x, y + 10), (x + 10, y),
+                                 (x + w - 10, y), (x + w, y + 10), (x + w, y + h)))
+            rings[0] = housing
+        pieces = [(ring, ring.get_rect(center=(0, 0))) for ring in rings]
+        for art, opacity in ((old, old_alpha), (portrait, alpha)):
+            if art is None or opacity <= 0:
+                continue
+            image = self.portrait(art.asset_id, art.mode == 2 and art.theme != 3)
+            if image is not None:
+                if opacity < 255:
+                    image = image.copy()
+                    image.set_alpha(opacity)
+                pieces.append((image, self.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_portrait(self, portrait, scale, *, box=None, old=None, alphas=(0, 255)):
+        if portrait is None or scale <= 0:
+            return
+        rect = self.resources.dialogue_layout().bank.rectangle(17, 0x30 if portrait.mode == 1 else 0x4e)
+        cx, cy = rect.center
+        cy -= 5  # FUN_000aaa40 uses 485-y when converting to GL.
+        clip = None if box is None else (box.x - 7 - cx, box.y - 7 - cy,
+                                         box.width + 14, box.height + 34)
+        layer, (x, y) = self.portrait_group(portrait, clip, old, *alphas)
+        if scale != 1:
+            size = max(1, round(layer.get_width() * scale)), max(1, round(layer.get_height() * scale))
+            layer = pygame.transform.smoothscale(layer, size)
+        self.canvas.blit(layer, (round(cx + x * scale), round(cy + y * scale)))
+
+    def draw_relationship(self, motion):
+        if motion.relationship is None or motion.portrait is None:
+            return
+        rect = self.resources.dialogue_layout().bank.rectangle(17, 0x30 if motion.portrait.mode == 1 else 0x4e)
+        cx, cy = rect.center
+        cy -= 5
+        # Indicator parents are siblings of the head's scaled node. They
+        # appear after its entrance and do not inherit the head-only flip.
+        for pose in motion.relationship.poses():
+            icon = self.ui_image(pose.asset_id)
+            if icon is None:
+                continue
+            image = pygame.transform.rotozoom(icon, -pose.rotation, 1)
+            center = round(cx + pose.x), round(cy + pose.y)
+            self.canvas.blit(image, image.get_rect(center=center))
+            if pose.flash_alpha:
+                flash = self.ui_image(pose.flash_asset)
+                if flash is not None:
+                    flash = pygame.transform.rotozoom(flash, -pose.rotation, pose.flash_scale)
+                    flash.set_alpha(pose.flash_alpha)
+                    self.canvas.blit(flash, flash.get_rect(center=center))
+
+    def draw_notice(self, engine):
+        portrait = engine.dialogue_animation.portrait
+        # This label belongs to the current portrait parent, which the native
+        # panel hides for narration and dialogue without character artwork.
+        if not engine.notice_ms or portrait is None:
+            return
+        motion = NoticeMotion(engine.notice, engine.notice_ms)
+        rect = self.resources.dialogue_layout().bank.rectangle(17, 0x30 if portrait.mode == 1 else 0x4e)
+        x, y = motion.origin(rect, portrait.mode)
+        # Native alignment 5 is top-left, with no automatic wrapping. Preserve
+        # the font's baked-in red lettering and white outline by using white RGB.
+        layout = self.text.layout(NOTICE_FONT, engine.notice, 2**31, NOTICE_STYLE)
+        for index, glyph in enumerate(layout.glyphs):
+            image = self.text._glyph_image(NOTICE_FONT, glyph, motion.scale)
+            if motion.alpha < 255:
+                image = image.copy()
+                image.set_alpha(motion.alpha)
+            self.canvas.blit(image, (round(x + glyph.x * motion.scale),
+                                     round(y + glyph.y * motion.scale - motion.glyph_rise(index))))
+
+    @lru_cache(maxsize=4)
+    def continue_tab(self, theme):
+        # GameModel::setBubbleSex chooses the supplied skin's frames 3–6.
+        tab = self.frame(126, {1: 5, 2: 3, 3: 6}.get(theme, 4)).copy()
+        font = 'TrebuchetMS_Bold14'
+        metrics = self.text.font(font)
+        height = getattr(metrics, 'cap_height', 14)
+        label = self.text.layout(font, MenuStrings.load(self.resources)[29], tab.get_width(), TextStyle(height))
+        left, top, right, bottom = label.ink_bounds
+        self.text.draw_layout(tab, font, label, (tab.get_width() - right - left) / 2,
+                              (tab.get_height() - bottom - top) / 2)
+        return tab
+
+    def draw_continue(self, box, theme, motion):
+        scale = motion.continue_scale
+        if scale <= 0:
+            return
+        tab = self.continue_tab(theme)
+        width, height = tab.get_size()
+        if scale < 1:
+            tab = pygame.transform.smoothscale(tab, (width, max(1, round(height * scale))))
+        # expandContinue: center = (bubble.width - 49.5, bubble.height + 8.5).
+        self.canvas.blit(tab, (box.x + box.width - width,
+                               box.y + box.height + round((height - tab.get_height()) / 2)))
+
+    @lru_cache(maxsize=1)
+    def footer_hint(self):
+        # GameModel::init / layout 18 node 2: ArialMT 11, white alpha 0xb0,
+        # centered in the 252x18 tooltip region below the story panel.
+        strings = MenuStrings.load(getattr(self.resources, 'library', self.resources))
+        name = 'ArialMT11'
+        label = self.text.layout(name, strings[36], 252, TextStyle(11, 0))
+        layer = pygame.Surface((252, 18), pygame.SRCALPHA).convert_alpha()
+        left, top, right, bottom = label.ink_bounds
+        self.text.draw_layout(layer, name, label,
+                              (252 - (right - left)) / 2 - left,
+                              (18 - (bottom - top)) / 2 - top)
+        layer.set_alpha(176)
+        return layer
+
+    def draw(self, target, session):
+        details = session.pending.details
+        key = id(session), session.scene, session.vm.steps_executed, details['page_start']
+        if key != self.cached_key:
+            self.cached_page = session.dialogue_page()
+            self.cached_key = key
+            self.name_layer.fill((0, 0, 0, 0))
+            if self.cached_page is not None:
+                page = self.cached_page
+                self.text.draw_layout(self.name_layer, page.name_font, page.name,
+                                      *page.name_origin, scale=page.name_scale)
+        page = self.cached_page
+        if page is None:
+            raise ContentError('Dialogue requires the imported APK layout and fonts')
+        self.canvas.fill((0, 0, 0))
+        self.draw_background(self.canvas, session.engine)
+        motion = session.engine.dialogue_animation
+        angle = motion.box_rotation
+        if angle or motion.box_scale != 1:
+            from .ui_assets import Rect
+            box = page.box
+            layer = pygame.Surface((box.width + 20, box.height + 20), pygame.SRCALPHA).convert_alpha()
+            self.box(layer, Rect(10, 10, box.width, box.height), details['theme'])
+            layer = pygame.transform.rotozoom(layer, -angle, motion.box_scale)
+            layer.set_alpha(motion.box_alpha)
+            self.canvas.blit(layer, layer.get_rect(center=box.center))
+        else:
+            origin = page.portrait
+            if origin is None and motion.anchor_mode:
+                origin = self.resources.dialogue_layout().bank.rectangle(17, 0x30 if motion.anchor_mode == 1 else 0x4e)
+            self.box(self.canvas, motion.box_rect(page.box, origin), details['theme'], alpha=motion.box_alpha)
+        self.draw_portrait(motion.previous, motion.previous_scale)
+        self.draw_portrait(motion.portrait, motion.portrait_scale,
+                           box=page.box if motion.housing_clipped else None,
+                           old=motion.initial_portrait, alphas=motion.expression_alphas)
+        self.draw_relationship(motion)
+        self.draw_notice(session.engine)
+        self.text.draw_layout(self.canvas, page.body_font, page.body, *page.body_origin,
+                              source_end=motion.revealed)
+        self.name_layer.set_alpha(motion.name_alpha)
+        self.canvas.blit(self.name_layer, (0, 0))
+        self.draw_continue(page.box, details['theme'], motion)
+        # Layout 18's footer and its original instruction, separate from the
+        # animated Continue tab attached to the dialogue box.
+        self.canvas.blit(self.frame(126, 47), (0, 431))
+        self.canvas.blit(self.footer_hint(), (63, 459))
+        target.blit(pygame.transform.smoothscale(self.canvas, target.get_size()), (0, 0))
+        return page

exp_runtime/desktop_input.py

@@ -0,0 +1,176 @@
+"""Services 17/40's APK layouts, bitmap labels, cursor and input alert."""
+from dataclasses import replace
+from functools import lru_cache
+
+from . import graphics as pygame
+
+from .content import ContentError
+from .fonts import TextStyle, layout_label
+from .menu import MenuStrings
+from .text_input import CURSOR_FONT, NAME_FONT
+from .ui_assets import Rect, read_ui
+
+
+BLUE = (41, 104, 221)
+INPUT_RECT = (30, 177, 260, 40)
+ALERT_RECT = (20, 160, 280, 160)
+
+
+class InputRenderer:
+    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=1)
+    def strings(self):
+        return MenuStrings.load(self.resources.library)
+
+    @lru_cache(maxsize=3)
+    def layout_image(self, index, width, height):
+        layer = pygame.Surface((width, height), pygame.SRCALPHA).convert_alpha()
+        bank = self.resources.dialogue_layout().bank
+        hidden_until = 0
+        for number, (node, rect) in enumerate(bank.walk(index, Rect(0, 0, width, height)), 1):
+            if number <= hidden_until:
+                continue
+            visible = node.flags & 16 and not (index == 46 and number in (1, 10))
+            # Visibility belongs to reference roots as well as images. The
+            # native layout-43 footer has a hidden button subtree, and
+            # 000d4658 explicitly hides layout-46 roots 1 and 10.
+            if node.kind == 7 and not visible:
+                hidden_until = number + sum(1 for _ in bank.walk(node.payload[0]))
+                continue
+            if node.kind == 1 and visible and rect.width > 0 and rect.height > 0:
+                slot, frame = node.payload
+                image = self.art.frame({0: 126, 2: 204, 3: 16}[slot], frame)
+                layer.blit(pygame.transform.scale(image, (rect.width, rect.height)), (rect.x, rect.y))
+        return layer
+
+    @lru_cache(maxsize=32)
+    def title(self, text):
+        name = 'ArialRoundedMTBold30'
+        font = self.text.font(name)
+        # 00165c14 rebuilds this label with BMFont's cumulative kerning when
+        # 000d4658 changes its anchor to (1/2,1). Other labels use 0004dc20.
+        layout = self.text.layout(name, text, 2**31, TextStyle(font.line_height, 0, BLUE))
+        glyphs, widths = [], []
+        placed = {g.index: g for g in layout.glyphs}
+        for line in layout.lines:
+            previous, width = -1, 0
+            for i in range(line.start, line.end):
+                code = ord(text[i])
+                adjustment = font.kernings.get((previous & 0xffff, code), 0)
+                if i in placed:
+                    g = placed[i]
+                    glyphs.append(replace(g, x=width + adjustment + g.glyph.xoffset))
+                width += font.glyph(text[i]).advance + adjustment
+                previous = code if code < 128 else code - 256
+            widths.append(width)
+        max_width = self.resources.dialogue_layout().bank.rectangle(46, 18).width
+        scale = min(1., max_width / layout.width) if layout.width else 1.
+        return replace(layout, glyphs=tuple(glyphs)), max(widths, default=0), scale
+
+    def _image(self, asset):
+        image = self.art.ui_image(asset)
+        if image is None:
+            raise ContentError(f'Name-entry artwork {asset} is missing')
+        return image
+
+    def alert(self):
+        # 707 is the alert's clickable panel, not the ordinary input screen.
+        ios = getattr(self.resources.library, 'kind', 'apk') == 'ipa'
+        if ios:
+            # The IPA uses UIKit's UIAlertView, with no exported panel image.
+            # Use the runtime's existing message skin for the desktop modal.
+            self.art.box(self.canvas, Rect(30, 170, 260, 140), 1)
+        else:
+            self.canvas.blit(self._image(707), ALERT_RECT[:2])
+        strings = self.strings()
+        for caption, origin, color in ((strings[258], (130, 169), (255, 255, 255)),
+                                        (strings[164], (140, 275), (0, 0, 0))):
+            label = self.text.layout('ArialRoundedMTBold20', caption, 2**31, TextStyle(16, -16, BLUE if ios else color))
+            self.text.draw_layout(self.canvas, 'ArialRoundedMTBold20', label, *origin)
+        label = layout_label(self.text.font('ArialRoundedMTBold16'), strings[260],
+                             280, 160, TextStyle(16, 2, BLUE if ios else (255, 255, 255)), 0x16)
+        # GL node (160,375), size (280,160), anchor (1/2,1/2).
+        self.text.draw_layout(self.canvas, 'ArialRoundedMTBold16', label, 20, 185)
+        return [(pygame.Rect(ALERT_RECT), ('input_dismiss',))]
+
+    def draw_ipa_entry(self, details, cursor_visible):
+        """000a0238/000a0880: layout 46 supplies the entire entry panel."""
+        bank = self.resources.dialogue_layout().bank
+        prompt_rect = bank.rectangle(46, 23)
+        prompt = self.text.layout('ArialRoundedMTBold16', details['prompt'], prompt_rect.width,
+                                  TextStyle(16, 10, BLUE))
+        height = max(1, round(prompt.height))
+        bounds = Rect((320 - bank.layouts[46].width) // 2, 151 - height,
+                      bank.layouts[46].width, bank.layouts[46].height + height - prompt_rect.height)
+        title_rect = bank.rectangle(46, 18, bounds)
+        title = self.text.layout('ArialRoundedMTBold30', details['title'], title_rect.width,
+                                 TextStyle(30, 0, BLUE))
+        active_header = 1 if title.height > title_rect.height else 10
+        hidden_until = 0
+        for number, (node, rect) in enumerate(bank.walk(46, bounds), 1):
+            if number <= hidden_until:
+                continue
+            visible = node.flags & 16 and (number not in (1, 10) or number == active_header)
+            if node.kind == 7 and not visible:
+                hidden_until = number + sum(1 for _ in bank.walk(node.payload[0]))
+                continue
+            if node.kind == 1 and visible and rect.width > 0 and rect.height > 0:
+                slot, frame = node.payload
+                image = self.art.frame({0: 126, 2: 204, 3: 16}[slot], frame)
+                self.canvas.blit(pygame.transform.scale(image, (rect.width, rect.height)), (rect.x, rect.y))
+        title_y = bank.rectangle(46, 9 if active_header == 1 else 18, bounds).y
+        self.text.draw_layout(self.canvas, 'ArialRoundedMTBold30', title,
+                              title_rect.x + (title_rect.width - title.width) / 2, title_y)
+        prompt_rect = bank.rectangle(46, 23, bounds)
+        self.text.draw_layout(self.canvas, 'ArialRoundedMTBold16', prompt, prompt_rect.x, prompt_rect.y)
+        entry = bank.rectangle(46, 44, bounds)
+        draft = details.get('draft', details['default'])
+        entered = self.text.layout('PajamaHip24', draft, 2**31, TextStyle(24))
+        self.text.draw_layout(self.canvas, 'PajamaHip24', entered, entry.x, entry.y)
+        if cursor_visible:
+            cursor = self.text.layout('PajamaHip24', '|', 2**31, TextStyle(24))
+            self.text.draw_layout(self.canvas, 'PajamaHip24', cursor, entry.x + entered.width, entry.y)
+        return [(pygame.Rect(entry.x, entry.y, entry.width, entry.height), ('input_focus',))]
+
+    def draw(self, target, session, *, error=None, cursor_visible=True):
+        self.canvas.fill((0, 0, 0))
+        self.art.draw_background(self.canvas, session.engine)
+        if error:
+            buttons = self.alert()
+        elif getattr(self.resources.library, 'kind', 'apk') == 'ipa':
+            buttons = self.draw_ipa_entry(session.pending.details, cursor_visible)
+        else:
+            bank = self.resources.dialogue_layout().bank
+            width = bank.layouts[46].width + 22
+            footer = bank.layouts[43]
+            # GL centers (160,415), (160,267), (160,340), in z order.
+            self.canvas.blit(self.layout_image(15, width, 50), (160 - width // 2, 40))
+            self.canvas.blit(self.layout_image(43, footer.width, footer.height),
+                             (160 - footer.width // 2, 213 - footer.height // 2))
+            self.canvas.blit(self.layout_image(46, width, 156), (160 - width // 2, 62))
+            details = session.pending.details
+            title, title_width, scale = self.title(details['title'])
+            self.text.draw_layout(self.canvas, 'ArialRoundedMTBold30', title,
+                                  160 - title_width * scale / 2, 65, scale=scale)
+            prompt = self.text.layout('ArialRoundedMTBold16', details['prompt'], 2**31,
+                                      TextStyle(16, -16, BLUE))
+            self.text.draw_layout(self.canvas, 'ArialRoundedMTBold16', prompt, 30, 120)
+            shadow = self._image(706)
+            self.canvas.blit(shadow, shadow.get_rect(center=(160, 197)))
+            draft = details.get('draft', details['default'])
+            entered = self.text.layout(NAME_FONT, draft, 2**31, TextStyle(26, -26, BLUE))
+            self.text.draw_layout(self.canvas, NAME_FONT, entered, 35, 190)
+            if cursor_visible:
+                cursor = self.text.layout(CURSOR_FONT, '|', 2**31, TextStyle(26, -26, BLUE))
+                # 000858cc creates '|' before setting nominal height 26.
+                # Unlike the name, the cursor is never assigned text again;
+                # its glyph keeps the initial zero-height line origin.
+                self.text.draw_layout(self.canvas, CURSOR_FONT, cursor, entered.width + 33, 214 - 26)
+            # Native confirmation is keyboard Return. No portrait-picker
+            # checkmark or common gear is attached by this panel's setup.
+            buttons = [(pygame.Rect(INPUT_RECT), ('input_focus',))]
+        target.blit(pygame.transform.smoothscale(self.canvas, target.get_size()), (0, 0))
+        return buttons