frontengine 1.0.83__tar.gz → 1.0.85__tar.gz

{frontengine-1.0.83/frontengine.egg-info → frontengine-1.0.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontengine
-Version: 1.0.83
+Version: 1.0.85
 Summary: FrontEngine is use-define frontview or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/JeffreyChen-SteamProjects/FrontEngine
@@ -422,6 +422,10 @@ Screen text: Tools → Read text first uses local OCR: Windows.Media.Ocr on Wind
 
 Puppet pets: install the optional puppet extra and an available Imervue runtime, then choose an original Imervue .puppet v1 file on the Pet page or drop it there. Existing image/sprite pet packs still work. Puppet pets use Imervue's canvas, motions and expressions, can be cloned or closed, and participate in FrontEngine's overlay controls and presets. Choose an optional .petscript.json for Imervue's existing script engine; do not treat FrontEngine pet.json packs as puppet files. Unknown versions, unsafe archive paths and invalid assets are rejected before runtime loading.
 
+Puppet pets also stroll on their own: after a few seconds' rest they walk a short way left or right along their current height with the walk motion, stay inside the screen's work area, then rest again. A stroll gives way to dragging, petting, Come here and toys, settling while typing, and modes that do not allow acting alone.
+
+The Behaviour menu's default, Cycle all actions (random), has a free pet pick what to do next at random from its whole set of actions; Walk on floor keeps only walking and idling. A sprite pet chooses among walking, idling, sitting, playing, grooming, climbing the nearer wall, waving, sleeping, celebrating and showing off its outfit; a Puppet pet chooses between a stroll and sitting, playing, grooming, waving or celebrating in place. A summoned pet sets off walking at once. Poses are held in place, and a pet without an image for a pose shows its idle image.
+
 Scenes: the Scene page accepts old entry-mapping JSON, a versioned frontengine.scene envelope, and portable .fescene packages. Add a PUPPET entry with position, size, opacity, finite numeric parameters, optional motion, expression and script. Paths in JSON resolve relative to the scene file. A .fescene includes the referenced media, original .puppet and optional .petscript.json so it can move between machines. Import checks paths, symlinks, versions and extraction limits. A FrontEngine scene remains a scene package; .puppet remains one Imervue character.
 
 macOS: the optional macos extra targets macOS 13+ with public PyObjC frameworks. Backends provide ScreenCaptureKit screen/window capture and system audio, microphone capture, Quartz window geometry, Accessibility window layout/movement, CoreMIDI, media keys and the F12 exit path. Screen Recording, Accessibility and Microphone permissions are checked separately; follow System Settings → Privacy & Security and restart when requested. Foreign-window opacity/topmost changes, Space selection and excluding overlays from other apps' captures remain unavailable. Native macOS permissions, hardware and performance have not been verified on this Windows development host. Settings → macOS permissions and capabilities lists each feature as available, unavailable or unsupported and shows the permission or installation reason.
@@ -482,6 +486,7 @@ it can be tested with a fake one.
   pull request, all CI checks green.
 - **Building the Windows executable** — `python exe/build_exe.py`
   (Nuitka; add `--onefile` for a single file).
+  It compiles on every CPU core by default; `--jobs N` caps the parallel jobs (less memory), `--jobs -N` leaves N cores free.
 - **Documentation** — Sphinx sources in `docs/`, published to
   [Read the Docs](https://frontengine.readthedocs.io/en/latest/) in all seven
   languages.
@@ -615,6 +620,8 @@ Customize pet also sets Chatter (Off, Rarely, Normal, Often) for lines the pet s
 
 The pet manager's interaction list also offers the selected live pet's own menu commands: photo, status, reminder, chat when a chat service is attached, clone and close, plus every motion and expression of a Puppet model. Everything in a pet's right-click menu can therefore be done with the keyboard.
 
+Use built-in character on the Pet page installs the chosen INKSIDE character and its wardrobe in the background and selects it as the source. Start then spawns an ordinary sprite pet wearing that character: it walks and climbs with the hand-drawn step frames, can be dressed in the wardrobe, and keeps its outfit when it already wears the character. Use built-in Puppet model beside it still makes the Imervue Puppet version.
+
 Use built-in Puppet model on the Pet page draws the chosen INKSIDE character as an Imervue .puppet model in the background: rigged head, arms, tail and body, ten motions, three expressions and a pet script that maps companion actions to them. It is saved under pet-assets/puppets and selected as the source with its script, so Start spawns it as a Puppet pet.
 
 On setups with several monitors at different scaling, a pet dragged or brought back to another monitor keeps its size, stays inside that monitor’s work area and walks there. Window ledges on scaled monitors are measured in the same coordinates as the pet, so it perches exactly on top of windows.

{frontengine-1.0.83 → frontengine-1.0.85}/README.md

@@ -371,6 +371,10 @@ Screen text: Tools → Read text first uses local OCR: Windows.Media.Ocr on Wind
 
 Puppet pets: install the optional puppet extra and an available Imervue runtime, then choose an original Imervue .puppet v1 file on the Pet page or drop it there. Existing image/sprite pet packs still work. Puppet pets use Imervue's canvas, motions and expressions, can be cloned or closed, and participate in FrontEngine's overlay controls and presets. Choose an optional .petscript.json for Imervue's existing script engine; do not treat FrontEngine pet.json packs as puppet files. Unknown versions, unsafe archive paths and invalid assets are rejected before runtime loading.
 
+Puppet pets also stroll on their own: after a few seconds' rest they walk a short way left or right along their current height with the walk motion, stay inside the screen's work area, then rest again. A stroll gives way to dragging, petting, Come here and toys, settling while typing, and modes that do not allow acting alone.
+
+The Behaviour menu's default, Cycle all actions (random), has a free pet pick what to do next at random from its whole set of actions; Walk on floor keeps only walking and idling. A sprite pet chooses among walking, idling, sitting, playing, grooming, climbing the nearer wall, waving, sleeping, celebrating and showing off its outfit; a Puppet pet chooses between a stroll and sitting, playing, grooming, waving or celebrating in place. A summoned pet sets off walking at once. Poses are held in place, and a pet without an image for a pose shows its idle image.
+
 Scenes: the Scene page accepts old entry-mapping JSON, a versioned frontengine.scene envelope, and portable .fescene packages. Add a PUPPET entry with position, size, opacity, finite numeric parameters, optional motion, expression and script. Paths in JSON resolve relative to the scene file. A .fescene includes the referenced media, original .puppet and optional .petscript.json so it can move between machines. Import checks paths, symlinks, versions and extraction limits. A FrontEngine scene remains a scene package; .puppet remains one Imervue character.
 
 macOS: the optional macos extra targets macOS 13+ with public PyObjC frameworks. Backends provide ScreenCaptureKit screen/window capture and system audio, microphone capture, Quartz window geometry, Accessibility window layout/movement, CoreMIDI, media keys and the F12 exit path. Screen Recording, Accessibility and Microphone permissions are checked separately; follow System Settings → Privacy & Security and restart when requested. Foreign-window opacity/topmost changes, Space selection and excluding overlays from other apps' captures remain unavailable. Native macOS permissions, hardware and performance have not been verified on this Windows development host. Settings → macOS permissions and capabilities lists each feature as available, unavailable or unsupported and shows the permission or installation reason.
@@ -431,6 +435,7 @@ it can be tested with a fake one.
   pull request, all CI checks green.
 - **Building the Windows executable** — `python exe/build_exe.py`
   (Nuitka; add `--onefile` for a single file).
+  It compiles on every CPU core by default; `--jobs N` caps the parallel jobs (less memory), `--jobs -N` leaves N cores free.
 - **Documentation** — Sphinx sources in `docs/`, published to
   [Read the Docs](https://frontengine.readthedocs.io/en/latest/) in all seven
   languages.
@@ -564,6 +569,8 @@ Customize pet also sets Chatter (Off, Rarely, Normal, Often) for lines the pet s
 
 The pet manager's interaction list also offers the selected live pet's own menu commands: photo, status, reminder, chat when a chat service is attached, clone and close, plus every motion and expression of a Puppet model. Everything in a pet's right-click menu can therefore be done with the keyboard.
 
+Use built-in character on the Pet page installs the chosen INKSIDE character and its wardrobe in the background and selects it as the source. Start then spawns an ordinary sprite pet wearing that character: it walks and climbs with the hand-drawn step frames, can be dressed in the wardrobe, and keeps its outfit when it already wears the character. Use built-in Puppet model beside it still makes the Imervue Puppet version.
+
 Use built-in Puppet model on the Pet page draws the chosen INKSIDE character as an Imervue .puppet model in the background: rigged head, arms, tail and body, ten motions, three expressions and a pet script that maps companion actions to them. It is saved under pet-assets/puppets and selected as the source with its script, so Start spawns it as a Puppet pet.
 
 On setups with several monitors at different scaling, a pet dragged or brought back to another monitor keeps its size, stays inside that monitor’s work area and walks there. Window ledges on scaled monitors are measured in the same coordinates as the pet, so it perches exactly on top of windows.

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/show/pet/desktop_pet.py

@@ -48,6 +48,7 @@ from frontengine.utils.multi_language.language_wrapper import language_wrapper
 BEHAVIOUR_FLOOR = "floor"    # walk on the floor with gravity, throw & bounce
 BEHAVIOUR_WANDER = "wander"  # free 2D bounce, no gravity
 BEHAVIOUR_CHASE = "chase"    # chase the mouse cursor, sleep when caught
+BEHAVIOUR_ACTIONS = "actions"  # floor mode cycling through every action at random (default)
 
 # 攀爬時所在的表面 / Surface the pet is crawling on while climbing
 SURFACE_FLOOR = "floor"
@@ -87,10 +88,21 @@ _STATE_FALLBACKS = {
     STATE_FALL: (STATE_WALK,),
     STATE_DRAG: (STATE_WALK,),
     **{action: (STATE_IDLE, STATE_WALK) for action in ("greet", "pet", "groom", "feed", "play", "sit",
-                                                       "land", "catch", "peer_greet", "wake")},
+                                                       "land", "catch", "peer_greet", "wake",
+                                                       "celebrate", "outfit_show")},
     "sleep_in": (STATE_SLEEP, STATE_IDLE, STATE_WALK),
 }
 
+# What a free pet does on its own, picked at random whenever its current state ends:
+# (state, weight, min ticks, max ticks) at 33 ms per tick. "climb" walks to the nearer
+# wall and climbs it; the poses are held in place, and groom lasts its 3 s animation.
+AUTONOMOUS_ACTIONS = (
+    ("walk", 34, 30, 120), ("idle", 14, 20, 80), ("sit", 10, 60, 150), ("play", 8, 45, 90),
+    ("groom", 7, 91, 91), ("climb", 6, 0, 0), ("greet", 5, 30, 55), ("sleep", 5, 120, 300),
+    ("celebrate", 4, 30, 60), ("outfit_show", 3, 45, 75),
+)
+POSE_STATES = frozenset(("sit", "play", "groom", "greet", "celebrate", "outfit_show"))
+
 # Short physical reactions shown over autonomous movement (milliseconds). They are
 # purely visual, so they never block toys, social play or user commands.
 _FLASH_MS = {"land": 280, "catch": 580, "peer_greet": 1600}
@@ -267,6 +279,8 @@ def derive_visual_state(dragging: bool, airborne: bool, surface: str, motion_sta
         return STATE_SLEEP
     if surface == SURFACE_FLOOR and motion_state == "idle":
         return STATE_IDLE
+    if surface == SURFACE_FLOOR and motion_state in POSE_STATES:
+        return motion_state
     return STATE_WALK
 
 
@@ -642,7 +656,7 @@ class PetMotion:
         self.height = int(height)
         self.bounds = bounds  # (left, top, right, bottom)
         self.speed = max(1, int(speed))
-        self.behaviour = behaviour
+        self.behaviour = behaviour  # property: BEHAVIOUR_ACTIONS becomes floor + random_actions
         self._rng = rng if rng is not None else _random_module.SystemRandom()
         self.vx = float(self.speed)
         self.vy = 0.0 if behaviour != BEHAVIOUR_WANDER else float(self.speed)
@@ -652,8 +666,9 @@ class PetMotion:
         # 打字時安分下來：True 的時候 step() 原地不動。
         # Settled while typing: step() stays put while this is True.
         self.settled = False
-        self.state = "walk"  # walk | idle | sleep
+        self.state = "walk"  # walk | idle | sleep | one of POSE_STATES
         self._state_ticks = 0
+        self._seek_wall = False  # walking to the nearer wall to climb it
         self._idle_count = 0
         self.target: Optional[Tuple[float, float]] = None
         self.asleep = False
@@ -672,6 +687,21 @@ class PetMotion:
         # game); it takes precedence over each mode's own default movement.
         self.guidance: Optional[Tuple[float, float]] = None
 
+    @property
+    def behaviour(self) -> str:
+        return self._behaviour
+
+    @behaviour.setter
+    def behaviour(self, value: str) -> None:
+        """BEHAVIOUR_ACTIONS is the floor mode with every action picked at random, so floor checks hold."""
+        self.random_actions = value == BEHAVIOUR_ACTIONS
+        self._behaviour = BEHAVIOUR_FLOOR if self.random_actions else value
+
+    @property
+    def mode(self) -> str:
+        """The behaviour as chosen, BEHAVIOUR_ACTIONS included; use this when saving or showing it."""
+        return BEHAVIOUR_ACTIONS if self.random_actions else self._behaviour
+
     @property
     def facing_left(self) -> bool:
         return self.vx < 0
@@ -822,7 +852,8 @@ class PetMotion:
 
     def _turn_or_climb(self, wall: str, turned_vx: float) -> None:
         """走到邊緣了：抓上牆去爬，或是掉頭往回走。"""
-        if self.climb and self._rng.random() < self.CLIMB_CHANCE:
+        if self.climb and (self._seek_wall or self._rng.random() < self.CLIMB_CHANCE):
+            self._seek_wall = False
             self.surface = wall
             self.vy = float(-self.speed)
         else:
@@ -1001,17 +1032,42 @@ class PetMotion:
             self.vy = float(self.speed)
 
     def _new_state(self, force_walk: bool = False) -> None:
-        if force_walk or self._rng.random() < 0.65:
-            self.state = "walk"
-            self._idle_count = 0
-            if not force_walk:
-                self.vx = float(self.speed) if self._rng.random() < 0.5 else float(-self.speed)
+        """Pick what to do next: walk or idle, or anything from AUTONOMOUS_ACTIONS in random-actions mode."""
+        self._seek_wall = False
+        if force_walk:
+            self.state, self._idle_count = "walk", 0
             self._state_ticks = self._rng.randint(30, 120)
-        elif self._idle_count >= 2:
+            return
+        if self._idle_count >= 2:
             # been idling a while -> doze off
-            self.state = STATE_SLEEP
-            self._idle_count = 0
+            self.state, self._idle_count = STATE_SLEEP, 0
             self._state_ticks = self._rng.randint(120, 300)
+            return
+        if not self.random_actions:
+            self._walk_or_idle()
+            return
+        options = [entry for entry in AUTONOMOUS_ACTIONS
+                   if entry[0] != STATE_CLIMB or (self.climb and not self.on_platform)]
+        name, _weight, low, high = self._rng.choices(options, weights=[entry[1] for entry in options])[0]
+        self._idle_count = self._idle_count + 1 if name == "idle" else 0
+        if name == STATE_CLIMB:
+            left, _top, right, _bottom = self.bounds
+            toward_left = self.x - left <= right - (self.x + self.width)
+            self.state, self._seek_wall = "walk", True
+            self.vx = float(-self.speed) if toward_left else float(self.speed)
+            self._state_ticks = 10 ** 6  # until the wall is reached
+            return
+        self.state = name
+        if name == "walk":
+            self.vx = float(self.speed) if self._rng.random() < 0.5 else float(-self.speed)
+        self._state_ticks = self._rng.randint(low, high)
+
+    def _walk_or_idle(self) -> None:
+        """The plain floor mode: mostly walking, sometimes idling."""
+        if self._rng.random() < 0.65:
+            self.state, self._idle_count = "walk", 0
+            self.vx = float(self.speed) if self._rng.random() < 0.5 else float(-self.speed)
+            self._state_ticks = self._rng.randint(30, 120)
         else:
             self.state = "idle"
             self._idle_count += 1
@@ -1250,7 +1306,7 @@ class DesktopPetWidget(BaseWidget):
         self.menu.addAction(self.photo_action)
         self._presentation_defaults = {
             "size": min(512, self._base_size), "speed": max(1, min(20, int(self.motion.speed))),
-            "behaviour": self.motion.behaviour, "climb": bool(self.motion.climb),
+            "behaviour": self.motion.mode, "climb": bool(self.motion.climb),
             "sit_on_windows": self._sit_on_windows, "speech_bubbles": self._talk,
             "volume": int(self._volume * 100), "settle_typing": False,
             "chatter": "normal", "motion": "normal",
@@ -1592,6 +1648,8 @@ class DesktopPetWidget(BaseWidget):
         self.motion.x = float(left)
         self.motion.y = float(bottom - self.pet_size)
         self.move(int(self.motion.x), int(self.motion.y))
+        # A freshly summoned pet sets off walking at once instead of rolling its first action.
+        self.motion.wake()
         self._tick_interval_ms = max(10, int(interval_ms))
         self._timer.start(scaled_interval(self._tick_interval_ms, self._low_power))
         self._schedule_chatter()
@@ -1889,7 +1947,7 @@ class DesktopPetWidget(BaseWidget):
         if action.get("status"):
             self.show_status()
         behaviour = action.get("behaviour")
-        if behaviour in (BEHAVIOUR_FLOOR, BEHAVIOUR_WANDER, BEHAVIOUR_CHASE):
+        if behaviour in (BEHAVIOUR_FLOOR, BEHAVIOUR_ACTIONS, BEHAVIOUR_WANDER, BEHAVIOUR_CHASE):
             self.motion.behaviour = behaviour
 
     def _check_reminders(self) -> None:

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/show/pet/pet_profile_session.py

@@ -125,7 +125,7 @@ class PetProfileSession(QObject):
         self.changed.emit()
         return True
 
-    def apply_appearance(self, expected: dict, candidate: dict, prepared=None) -> None:
+    def apply_appearance(self, expected: dict, candidate: dict, prepared=None, present: bool = True) -> None:
         """Persist a prevalidated/preloaded wardrobe draft without stale overwrites."""
         if self._closed:
             raise ValueError("Pet session is closed")
@@ -134,7 +134,7 @@ class PetProfileSession(QObject):
             raise ValueError("Pet appearance changed while previewing")
         self.profiles.update(self.identifier, {**self.companion.snapshot(), "appearance": candidate})
         self.appearance_renderer = prepared
-        if candidate != expected:
+        if present and candidate != expected:
             self.companion.present('outfit_show')
         self.changed.emit()
 

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/show/pet/puppet_pet.py

@@ -17,6 +17,7 @@ from frontengine.utils.multi_language.retranslate import translate
 from frontengine.show.pet.companion_menu import add_companion_actions, add_food_actions, companion_status
 from frontengine.show.pet.puppet_reactions import PuppetReactions, load_reactions
 from frontengine.utils.pet_companion.petting import PettingGesture
+from frontengine.show.pet.puppet_stroll import PuppetStroll
 from frontengine.show.pet.puppet_target import PuppetTargetController
 
 
@@ -56,6 +57,7 @@ class PuppetPetWidget(DraggableTopWindow):
         self._follows_screen = False
         self._petting_revision = None
         self._target = PuppetTargetController(self)
+        self._stroll = PuppetStroll(self)
         self.placement_revision = 0
         self._talk = True
         self._initial_size = size
@@ -221,15 +223,24 @@ class PuppetPetWidget(DraggableTopWindow):
         if settled:
             self.stop_toy()
             self._end_petting()
-        self.idle.set_enabled(self.isVisible() and not settled
+            self._stroll.stop()
+        elif self.isVisible() and not self._closed:
+            self._stroll.start()
+        self._show_activity()
+
+    def _show_activity(self) -> None:
+        """Idle, walk or the companion's action, from what is currently moving the pet."""
+        moving = self._target.marker is not None or self._stroll.walking
+        acting = self._stroll.acting if self._target.marker is None else None
+        self.idle.set_enabled(self.isVisible() and not self._settled
                               and self._petting is None
-                              and self._target.marker is None
+                              and not moving and acting is None
                               and self.profile_session.companion.allows_autonomy)
-        if settled:
+        if self._settled:
             self.reactions.reset()
             self.player.stop()
         elif self.isVisible():
-            self.reactions.update('walk' if self._target.marker is not None else self.profile_session.companion.visual_action)
+            self.reactions.update('walk' if moving else acting or self.profile_session.companion.visual_action)
 
     def contextMenuEvent(self, event) -> None:
         words = language_wrapper.language_word_dict
@@ -483,6 +494,8 @@ class PuppetPetWidget(DraggableTopWindow):
             handle.screenChanged.connect(lambda _screen: QTimer.singleShot(0, self, self._follow_screen))
         if not self._closed:
             self.profile_session.resume()
+            if not self._welcomed and not self._settled:
+                self._stroll.start(soon=True)   # a summoned pet sets off at once
             self.set_settled(self._settled)
             self.script_timer.start()
             if not self._welcomed:
@@ -493,6 +506,7 @@ class PuppetPetWidget(DraggableTopWindow):
     def hideEvent(self, event) -> None:
         if not self._closed:
             self.stop_toy()
+            self._stroll.stop()
             self._end_petting()
             self.reactions.reset()
             self.profile_session.pause()
@@ -510,6 +524,7 @@ class PuppetPetWidget(DraggableTopWindow):
             return False
         self._closed = True
         self.stop_toy()
+        self._stroll.stop()
         self._end_petting()
         self.reactions.reset()
         self.script_timer.stop()

frontengine-1.0.85/frontengine/show/pet/puppet_stroll.py

@@ -0,0 +1,132 @@
+"""Autonomous behaviour for Puppet pets: after each rest, a short walk or a random action."""
+from __future__ import annotations
+
+import random
+from time import monotonic
+
+from PySide6.QtCore import QObject, QTimer
+
+
+class PuppetStroll(QObject):
+    """Now and then walk the pet left or right, or play a random action in place.
+
+    It yields to everything that already owns the pet: dragging, petting, a call or
+    toy target, settling while typing and companion modes without autonomy. The
+    pet ends every walk inside its screen's work area.
+    """
+
+    SPEED = 70.0              # pixels per second
+    REST_SECONDS = (3.0, 8.0)
+    DISTANCE = (120, 420)     # pixels per walk
+    # What the pet does after each rest, picked at random: (action, weight).
+    CHOICES = (('walk', 50), ('sit', 12), ('play', 10), ('groom', 9), ('greet', 10), ('celebrate', 9))
+    HOLD_SECONDS = {'groom': (3.0, 3.0)}   # others hold 2-4 s
+
+    def __init__(self, pet, rng: random.Random | None = None) -> None:
+        super().__init__(pet)
+        self.pet = pet
+        self.rng = rng or random.Random()  # nosec B311 - stroll timing and distance only, not security
+        self.walking = False
+        self.acting: str | None = None   # action played in place
+        self._walk_next = False           # a newly summoned pet walks off first
+        self._hold = 0.0
+        self.target_x: int | None = None
+        self._x = 0.0
+        self._last = monotonic()
+        self._rest = QTimer(self)
+        self._rest.setSingleShot(True)
+        self._rest.timeout.connect(self._begin)
+        self._step = QTimer(self)
+        self._step.setInterval(33)
+        self._step.timeout.connect(self.tick)
+
+    def _free(self) -> bool:
+        return self.pet.can_play_with_toy and self.pet._target.marker is None
+
+    def _span(self) -> tuple[int, int] | None:
+        screen = self.pet.screen()
+        if screen is None:
+            return None
+        area = screen.availableGeometry()
+        left, right = area.left(), area.right() + 1 - self.pet.width()
+        return (left, right) if right > left else None
+
+    def start(self, soon: bool = False) -> None:
+        """Schedule the next walk or action unless one is already waiting or under way.
+
+        ``soon`` is for a pet that was just summoned: it sets off walking almost at once.
+        """
+        if not self.walking and self.acting is None and not self._rest.isActive():
+            self._walk_next = soon
+            self._rest.start(300 if soon else round(1000 * self.rng.uniform(*self.REST_SECONDS)))
+
+    def stop(self) -> None:
+        """Stop walking, acting and waiting; nothing resumes until start() is called."""
+        self._rest.stop()
+        self._step.stop()
+        if self.walking or self.acting is not None:
+            self.walking, self.acting, self.target_x = False, None, None
+            self.pet._show_activity()
+
+    def _choose(self) -> str:
+        names = [name for name, _weight in self.CHOICES]
+        return self.rng.choices(names, weights=[weight for _name, weight in self.CHOICES])[0]
+
+    def _act(self, action: str) -> None:
+        """Play one action in place for its hold time."""
+        self.acting = action
+        self._hold = self.rng.uniform(*self.HOLD_SECONDS.get(action, (2.0, 4.0)))
+        self._last = monotonic()
+        self._step.start()
+        self.pet._show_activity()
+
+    def _begin(self) -> None:
+        span = self._span()
+        if not self._free() or span is None:
+            self.start()
+            return
+        choice = 'walk' if self._walk_next else self._choose()
+        self._walk_next = False
+        if choice != 'walk':
+            self._act(choice)
+            return
+        left, right = span
+        distance = self.rng.randint(*self.DISTANCE)
+        x = self.pet.x()
+        options = [min(max(x + sign * distance, left), right) for sign in self.rng.sample((-1, 1), 2)]
+        target = next((option for option in options if abs(option - x) >= 20), None)
+        if target is None:
+            self.start()
+            return
+        self.target_x, self._x, self._last = target, float(x), monotonic()
+        self.walking = True
+        self._step.start()
+        self.pet._show_activity()
+
+    def tick(self, elapsed: float | None = None) -> None:
+        if not self.walking and self.acting is None:
+            return
+        if not self._free():
+            self._finish()
+            return
+        now = monotonic()
+        dt = max(0.0, min(0.05, now - self._last if elapsed is None else elapsed))
+        self._last = now
+        if self.acting is not None:
+            self._hold -= dt
+            if self._hold <= 0:
+                self._finish()
+            return
+        remaining = self.target_x - self._x
+        step = min(abs(remaining), self.SPEED * dt)
+        self._x += step if remaining > 0 else -step
+        self.pet.move(round(self._x), self.pet.y())
+        if abs(self.target_x - self._x) < 0.5:
+            self._finish()
+
+    def _finish(self) -> None:
+        self._step.stop()
+        self.walking, self.acting, self.target_x = False, None, None
+        self.pet._show_activity()
+        if not self.pet._closed and self.pet.isVisible() and not self.pet._settled:
+            self.start()

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/show/pet/wardrobe.py

@@ -224,8 +224,11 @@ class WardrobeDraft:
         self._candidate = copy.deepcopy(self._expected)
         self.preview = None
 
-    def apply(self) -> LayeredRenderer | None:
-        """Preload, compare and persist. Failure leaves the draft and saved state intact."""
+    def apply(self, present: bool = True) -> LayeredRenderer | None:
+        """Preload, compare and persist. Failure leaves the draft and saved state intact.
+
+        ``present`` plays the outfit show on a live pet; summoning skips it so the pet moves at once.
+        """
         candidate = self.appearance
         self._validate(candidate)
         prepared = self.catalog.prepare(candidate)
@@ -233,7 +236,7 @@ class WardrobeDraft:
         if session:
             if not getattr(session.parent(), 'supports_layered_wardrobe', True):
                 raise ValueError('This active pet does not support layered sprite clothing')
-            session.apply_appearance(self._expected, candidate, prepared)
+            session.apply_appearance(self._expected, candidate, prepared, present=present)
         else:
             if self.profiles.get(self.identifier)['appearance'] != self._expected:
                 raise ValueError('Pet appearance changed while previewing')

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/ui/dialog/pet_asset_install.py

@@ -63,3 +63,33 @@ class PetBuiltinInstall(QRunnable):
         except (OSError, ValueError) as failure:
             error = str(failure)
         self.signals.finished.emit(error)
+
+
+class SpriteSignals(QObject):
+    finished = Signal(str, str)   # preview image path, error
+
+
+class PetBuiltinSprite(QRunnable):
+    """Install a built-in character for sprite pets and render its idle frame as the pet image."""
+
+    def __init__(self, library, identifier, preview_folder):
+        super().__init__()
+        self.library, self.identifier, self.preview_folder = library, identifier, preview_folder
+        self.cancel = Event()
+        self.signals = SpriteSignals()
+
+    def run(self) -> None:
+        from frontengine.show.pet.inkside.library import VERSION, install_builtin
+        from frontengine.show.pet.layered_renderer import LayeredRenderer
+        try:
+            install_builtin(self.library, self.identifier, self.cancel)
+            catalog, _errors = self.library.scan()
+            character = catalog.resolve({'id': self.identifier, 'version': VERSION}, 'character')
+            self.preview_folder.mkdir(parents=True, exist_ok=True)
+            preview = self.preview_folder / f'{self.identifier}.png'
+            if not LayeredRenderer(character).render('idle', 0).save(str(preview), 'PNG'):
+                raise OSError(f'Could not write {preview}')
+        except (OSError, ValueError) as failure:
+            self.signals.finished.emit('', str(failure))
+            return
+        self.signals.finished.emit(str(preview), '')

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/ui/dialog/pet_customization.py

@@ -87,7 +87,7 @@ class PetCustomizationDialog(QDialog):
             self.controls[key] = control
             form.addRow(tr(QLabel(), 'pet_' + key + '_label', key.title()), control)
         for key, values, label, fallback in (
-                ('behaviour', ('floor', 'wander', 'chase'), 'pet_behaviour_label', 'Behaviour'),
+                ('behaviour', ('actions', 'floor', 'wander', 'chase'), 'pet_behaviour_label', 'Behaviour'),
                 ('chatter', CHATTER_LEVELS, 'pet_chatter_label', 'Chatter'),
                 ('motion', MOTION_LEVELS, 'pet_motion_label', 'Animation size')):
             control = QComboBox()

{frontengine-1.0.83 → frontengine-1.0.85}/frontengine/ui/page/pet/pet_setting_ui.py

@@ -9,7 +9,7 @@ from PySide6.QtWidgets import (
 )
 
 from frontengine.show.pet.desktop_pet import (
-    DesktopPetWidget, BEHAVIOUR_FLOOR, BEHAVIOUR_WANDER, BEHAVIOUR_CHASE, PetTagGame, scan_pet_pack,
+    DesktopPetWidget, BEHAVIOUR_ACTIONS, BEHAVIOUR_FLOOR, BEHAVIOUR_WANDER, BEHAVIOUR_CHASE, PetTagGame, scan_pet_pack,
 )
 from frontengine.ui.dialog.choose_file_dialog import choose_pet, choose_wav_sound
 from frontengine.ui.page.utils import (
@@ -96,13 +96,18 @@ class PetSettingUI(SettingPage):
         self.choose_script_button = tr(QPushButton(), 'pet_choose_script', 'Choose puppet script...')
         self.choose_script_button.clicked.connect(self.choose_puppet_script)
         from frontengine.show.pet.inkside.library import builtin_names
-        self.builtin_puppet = QComboBox()
-        tr(self.builtin_puppet, 'pet_builtin_puppet_pick', 'Built-in Puppet character', 'setAccessibleName')
+        self.builtin_character = QComboBox()
+        tr(self.builtin_character, 'pet_builtin_character_pick', 'Built-in character', 'setAccessibleName')
         for identifier, name in builtin_names():
-            self.builtin_puppet.addItem(name, identifier)
+            self.builtin_character.addItem(name, identifier)
+        self.builtin_sprite_button = tr(QPushButton(), 'pet_builtin_character', 'Use built-in character')
+        self.builtin_sprite_button.clicked.connect(self.use_builtin_character)
         self.builtin_puppet_button = tr(QPushButton(), 'pet_builtin_puppet', 'Use built-in Puppet model')
         self.builtin_puppet_button.clicked.connect(self.use_builtin_puppet)
         self._puppet_export = None
+        self._sprite_install = None
+        # (character id, preview image): Start dresses a sprite pet spawned from that image as the character.
+        self._builtin_sprite: tuple[str, str] | None = None
         self.ready_label = tr(QLabel(), "Not Ready")
 
         # Size
@@ -120,6 +125,10 @@ class PetSettingUI(SettingPage):
         # Behaviour
         self.behaviour_label = tr(QLabel(), "pet_behaviour_label", "Behaviour")
         self.behaviour_combobox = QComboBox()
+        # First item is the default: the floor mode cycling through every action at random.
+        self.behaviour_combobox.addItem(
+            language_wrapper.language_word_dict.get("pet_behaviour_actions", "Cycle all actions (random)"),
+            BEHAVIOUR_ACTIONS)
         self.behaviour_combobox.addItem(
             language_wrapper.language_word_dict.get("pet_behaviour_floor", "Walk on floor"), BEHAVIOUR_FLOOR)
         self.behaviour_combobox.addItem(
@@ -204,9 +213,10 @@ class PetSettingUI(SettingPage):
         puppet_row = QWidget()
         puppet_layout = QHBoxLayout(puppet_row)
         puppet_layout.setContentsMargins(0, 0, 0, 0)
-        puppet_layout.addWidget(self.builtin_puppet)
+        puppet_layout.addWidget(self.builtin_character)
+        puppet_layout.addWidget(self.builtin_sprite_button)
         puppet_layout.addWidget(self.builtin_puppet_button)
-        source.add_row('pet_builtin_puppet_pick', puppet_row, 'Built-in Puppet character')
+        source.add_row('pet_builtin_character_pick', puppet_row, 'Built-in character')
         self.profile_controls = PetProfileControls(self)
 
         appearance = self.add_section("section_appearance", "Appearance")
@@ -339,6 +349,8 @@ class PetSettingUI(SettingPage):
             profile_id=identifier, profiles=self.profile_controls.profiles,
             profile_name=self.profile_controls.name.text(),
         )
+        if source_pet is None and self._builtin_sprite is not None and path == self._builtin_sprite[1]:
+            self._dress_as_builtin(pet, self._builtin_sprite[0])
         pet.clone_requested.connect(lambda: self._spawn_pet(pet.profile_session.state(), source_pet=pet))
         pet.customize_requested.connect(lambda: self.profile_controls.customize(pet.profile_session.identifier))
         pet.profile_session.changed.connect(self._on_settle_typing_toggled)
@@ -400,7 +412,7 @@ class PetSettingUI(SettingPage):
         if self._puppet_export is not None:
             return
         self.builtin_puppet_button.setEnabled(False)
-        job = PuppetExport(self.builtin_puppet.currentData(), Path.cwd() / 'pet-assets' / 'puppets')
+        job = PuppetExport(self.builtin_character.currentData(), Path.cwd() / 'pet-assets' / 'puppets')
         self._puppet_export = job
         job.signals.finished.connect(self._builtin_puppet_ready, Qt.ConnectionType.QueuedConnection)
         QThreadPool.globalInstance().start(job)
@@ -416,6 +428,42 @@ class PetSettingUI(SettingPage):
         self.ready_to_play = True
         self.ready_label.setText(language_wrapper.language_word_dict.get("Ready"))
 
+    def use_builtin_character(self) -> None:
+        """Install the chosen INKSIDE character for sprite pets; Start then spawns a pet dressed as it."""
+        from frontengine.show.pet.asset_library import PetAssetLibrary
+        from frontengine.ui.dialog.pet_asset_install import PetBuiltinSprite
+        if self._sprite_install is not None:
+            return
+        self.builtin_sprite_button.setEnabled(False)
+        job = PetBuiltinSprite(PetAssetLibrary(), self.builtin_character.currentData(), Path.cwd() / 'pet-previews')
+        self._sprite_install = job
+        job.signals.finished.connect(self._builtin_character_ready, Qt.ConnectionType.QueuedConnection)
+        QThreadPool.globalInstance().start(job)
+
+    def _builtin_character_ready(self, preview: str, error: str) -> None:
+        identifier, self._sprite_install = self._sprite_install.identifier, None
+        self.builtin_sprite_button.setEnabled(True)
+        if error:
+            self.profile_controls.status.setText(error)
+            return
+        self.pet_image_path = preview
+        self.puppet_script_path = None
+        self._builtin_sprite = (identifier, preview)
+        self.ready_to_play = True
+        self.ready_label.setText(language_wrapper.language_word_dict.get("Ready"))
+
+    def _dress_as_builtin(self, pet, identifier: str) -> None:
+        """Give the pet's identity the built-in character, unless it already wears it."""
+        from frontengine.show.pet.inkside.library import VERSION
+        from frontengine.show.pet.wardrobe import WardrobeDraft
+        reference = {'id': identifier, 'version': VERSION}
+        if (pet.profile_session.state().get('appearance') or {}).get('character') == reference:
+            return
+        catalog, _errors = pet.asset_library.scan()
+        draft = WardrobeDraft(self.profile_controls.profiles, pet.profile_session.identifier, catalog)
+        draft.choose_character(reference)
+        draft.apply(present=False)   # no outfit show: a summoned pet sets off at once
+
     def choose_puppet_script(self) -> None:
         path, _ = QFileDialog.getOpenFileName(self, 'Imervue pet script', '', 'Pet script (*.petscript.json)')
         if path: