From e1b73b996db0ecef8f1d2e21deda5c6dbbb9f321 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:25:49 -0400
Subject: [PATCH 01/23] The computer conversation panel now shows what the game
 shows:

- the leader's Computer Use and Repair totals and the party's computer
  spikes and repair parts, written once per entry, when its replies are
  listed;
- the two skill names from skills.2da, and in KotOR their icons;
- the terminal hum, computer_lp_04, looping at 30 of 127 while the panel
  is up and stopping for a camera shot;
- in KotOR, the panel frame from comptypes.2da by the dialogue's
  ComputerType, and the four static bands drawn at 40% opacity instead
  of hidden.
---
 include/reone/game/gui/computer.h |  46 ++++++++---
 include/reone/gui/control.h       |   4 +
 src/libs/game/gui/computer.cpp    | 122 ++++++++++++++++++++++++++----
 src/libs/gui/control.cpp          |  22 +++---
 test/game/computer.cpp            |   8 ++
 5 files changed, 168 insertions(+), 34 deletions(-)

diff --git a/include/reone/game/gui/computer.h b/include/reone/game/gui/computer.h
index a8320b645..e8c86dabc 100644
--- a/include/reone/game/gui/computer.h
+++ b/include/reone/game/gui/computer.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "reone/audio/clip.h"
 #include "reone/gui/control/label.h"
 #include "reone/gui/control/listbox.h"
 
@@ -54,8 +55,20 @@ class ComputerGUI : public Conversation {
 
     ComputerCamGUI _cameraGUI;
     Presentation _presentation {Presentation::Normal};
+    /** The terminal hum, looping while the panel is up. */
+    std::shared_ptr<audio::AudioClip> _humClip;
+    /** The playing hum; none while the panel is down or a camera shot shows. */
+    std::shared_ptr<audio::AudioSource> _hum;
+    /** KotOR: the panel frame of each computer type, the rows of comptypes.2da. */
+    std::vector<std::string> _panelFrames;
 
     void returnFromCamera();
+    /** Switches between the panel and a camera shot; the terminal hum plays only with the panel. */
+    void setPresentation(Presentation presentation);
+    /** Starts the terminal hum from its beginning. */
+    void playHum();
+    /** Stops the terminal hum. */
+    void stopHum();
 
     struct Controls {
         std::shared_ptr<gui::Label> LBL_BAR1;
@@ -98,29 +111,42 @@ class ComputerGUI : public Conversation {
         _controls.LBL_BAR5 = findControl<gui::Label>("LBL_BAR5");
         _controls.LBL_BAR6 = findControl<gui::Label>("LBL_BAR6");
         _controls.LBL_COMP_SKILL = findControl<gui::Label>("LBL_COMP_SKILL");
-        _controls.LBL_COMP_SKILL_ICON = findControl<gui::Label>("LBL_COMP_SKILL_ICON");
         _controls.LBL_COMP_SKILL_VAL = findControl<gui::Label>("LBL_COMP_SKILL_VAL");
         _controls.LBL_COMP_SPIKES = findControl<gui::Label>("LBL_COMP_SPIKES");
-        _controls.LBL_COMP_SPIKES_ICON = findControl<gui::Label>("LBL_COMP_SPIKES_ICON");
         _controls.LBL_COMP_SPIKES_VAL = findControl<gui::Label>("LBL_COMP_SPIKES_VAL");
-        _controls.LBL_OBSCURE = findControl<gui::Label>("LBL_OBSCURE");
         _controls.LBL_REP_SKILL = findControl<gui::Label>("LBL_REP_SKILL");
-        _controls.LBL_REP_SKILL_ICON = findControl<gui::Label>("LBL_REP_SKILL_ICON");
         _controls.LBL_REP_SKILL_VAL = findControl<gui::Label>("LBL_REP_SKILL_VAL");
         _controls.LBL_REP_UNITS = findControl<gui::Label>("LBL_REP_UNITS");
-        _controls.LBL_REP_UNITS_ICON = findControl<gui::Label>("LBL_REP_UNITS_ICON");
         _controls.LBL_REP_UNITS_VAL = findControl<gui::Label>("LBL_REP_UNITS_VAL");
-        _controls.LBL_STATIC1 = findControl<gui::Label>("LBL_STATIC1");
-        _controls.LBL_STATIC2 = findControl<gui::Label>("LBL_STATIC2");
-        _controls.LBL_STATIC3 = findControl<gui::Label>("LBL_STATIC3");
-        _controls.LBL_STATIC4 = findControl<gui::Label>("LBL_STATIC4");
         _controls.LB_MESSAGE = findControl<gui::ListBox>("LB_MESSAGE");
         _controls.LB_REPLIES = findControl<gui::ListBox>("LB_REPLIES");
+        if (!isTSL()) {
+            // Only the KotOR terminal sets up the skill icons, the obscuring
+            // label and the static bands.
+            _controls.LBL_COMP_SKILL_ICON = findControl<gui::Label>("LBL_COMP_SKILL_ICON");
+            _controls.LBL_COMP_SPIKES_ICON = findControl<gui::Label>("LBL_COMP_SPIKES_ICON");
+            _controls.LBL_OBSCURE = findControl<gui::Label>("LBL_OBSCURE");
+            _controls.LBL_REP_SKILL_ICON = findControl<gui::Label>("LBL_REP_SKILL_ICON");
+            _controls.LBL_REP_UNITS_ICON = findControl<gui::Label>("LBL_REP_UNITS_ICON");
+            _controls.LBL_STATIC1 = findControl<gui::Label>("LBL_STATIC1");
+            _controls.LBL_STATIC2 = findControl<gui::Label>("LBL_STATIC2");
+            _controls.LBL_STATIC3 = findControl<gui::Label>("LBL_STATIC3");
+            _controls.LBL_STATIC4 = findControl<gui::Label>("LBL_STATIC4");
+        }
     }
 
     void configureMessage();
     void configureReplies();
-    void hideStaticBands();
+    /** Names the two skills, and in KotOR shows their icons. */
+    void configureSkillLabels();
+    /** KotOR draws the static bands faintly. */
+    void configureBands();
+    /** KotOR reads the panel frame of each computer type. */
+    void loadPanelFrames();
+    /** KotOR frames the panel by the conversation's computer type. */
+    void applyPanelFrame();
+    /** Writes the leader's Computer Use and Repair totals and the party's spike and repair-part counts. */
+    void refreshSkills();
 
     void setMessage(std::string message) override;
     void setReplyLines(std::vector<std::string> lines) override;
diff --git a/include/reone/gui/control.h b/include/reone/gui/control.h
index 586e721da..90b5098c3 100644
--- a/include/reone/gui/control.h
+++ b/include/reone/gui/control.h
@@ -96,6 +96,8 @@ class Control : boost::noncopyable {
         std::shared_ptr<graphics::Texture> edge;
         std::shared_ptr<graphics::Texture> fill;
         glm::vec3 color {1.0f};
+        /** The opacity every piece of the border is drawn with. */
+        float alpha {1.0f};
         int dimension {0};
         FillTransform fillTransform {FillTransform::None};
     };
@@ -166,6 +168,8 @@ class Control : boost::noncopyable {
     void setBorderFill(std::shared_ptr<graphics::Texture> texture);
     void setBorderFillTransform(Border::FillTransform transform);
     void setBorderColor(glm::vec3 color);
+    /** Sets the opacity every piece of the border is drawn with. */
+    void setBorderAlpha(float alpha);
     void setBorderColorOverride(glm::vec3 color);
     void setDisabled(bool disabled);
     virtual void setExtent(Extent extent);
diff --git a/src/libs/game/gui/computer.cpp b/src/libs/game/gui/computer.cpp
index 2a0b2a50c..336f9ced2 100644
--- a/src/libs/game/gui/computer.cpp
+++ b/src/libs/game/gui/computer.cpp
@@ -17,7 +17,18 @@
 
 #include "reone/game/gui/computer.h"
 
+#include "reone/audio/di/services.h"
+#include "reone/audio/mixer.h"
+#include "reone/game/d20/skills.h"
+#include "reone/game/di/services.h"
 #include "reone/game/game.h"
+#include "reone/game/object/creature.h"
+#include "reone/game/party.h"
+#include "reone/game/twodautil.h"
+#include "reone/resource/2da.h"
+#include "reone/resource/di/services.h"
+#include "reone/resource/provider/2das.h"
+#include "reone/resource/provider/audioclips.h"
 
 using namespace reone::audio;
 
@@ -29,15 +40,19 @@ namespace reone {
 
 namespace game {
 
-static void setVisible(const std::shared_ptr<Label> &control, bool visible) {
-    if (control) {
-        control->setVisible(visible);
-    }
-}
+static constexpr char kHumResRef[] = "computer_lp_04";
+static constexpr float kHumGain = 30.0f / 127.0f;
+static constexpr char kComputerSpikeTag[] = "k_computer_spike";
+static constexpr char kRepairPartTag[] = "k_repair_part";
+static constexpr float kStaticBandAlpha = 0.4f;
+static constexpr char kComputerTypesResRef[] = "comptypes";
 
 void ComputerGUI::init() {
     Conversation::init();
     _cameraGUI.init();
+    if (!isTSL()) {
+        loadPanelFrames();
+    }
 }
 
 bool ComputerGUI::handle(const input::Event &event) {
@@ -63,23 +78,26 @@ void ComputerGUI::render() {
 }
 
 void ComputerGUI::onStart() {
+    applyPanelFrame();
     _presentation = Presentation::Normal;
+    playHum();
 }
 
 void ComputerGUI::onFinish() {
     _presentation = Presentation::Normal;
+    stopHum();
 }
 
 void ComputerGUI::onLoadEntry() {
     int cameraId = 0;
-    _presentation = getCamera(cameraId) == CameraType::Static ? Presentation::Camera : Presentation::Normal;
+    setPresentation(getCamera(cameraId) == CameraType::Static ? Presentation::Camera : Presentation::Normal);
     if (_presentation == Presentation::Camera) {
         _cameraGUI.clearSelection();
     }
 }
 
 void ComputerGUI::onEntryEnded() {
-    _presentation = Presentation::Normal;
+    setPresentation(Presentation::Normal);
 }
 
 void ComputerGUI::returnFromCamera() {
@@ -88,6 +106,31 @@ void ComputerGUI::returnFromCamera() {
     }
 }
 
+void ComputerGUI::setPresentation(Presentation presentation) {
+    if (presentation == _presentation) {
+        return;
+    }
+    _presentation = presentation;
+    if (_presentation == Presentation::Camera) {
+        stopHum();
+    } else {
+        playHum();
+    }
+}
+
+void ComputerGUI::playHum() {
+    stopHum();
+    _hum = _services.audio.mixer.play(_humClip, AudioType::Sound, kHumGain, true);
+}
+
+void ComputerGUI::stopHum() {
+    if (!_hum) {
+        return;
+    }
+    _hum->stop();
+    _hum.reset();
+}
+
 void ComputerGUI::preload(IGUI &gui) {
     GameGUI::preload(gui);
 }
@@ -96,7 +139,9 @@ void ComputerGUI::onGUILoaded() {
     bindControls();
     configureMessage();
     configureReplies();
-    hideStaticBands();
+    configureSkillLabels();
+    configureBands();
+    _humClip = _services.resource.audioClips.get(kHumResRef);
 }
 
 void ComputerGUI::configureMessage() {
@@ -115,16 +160,60 @@ void ComputerGUI::configureReplies() {
     });
 }
 
-void ComputerGUI::hideStaticBands() {
-    if (_game.isTSL()) {
+void ComputerGUI::configureSkillLabels() {
+    const auto &computerUse = *_services.game.skills.get(SkillType::ComputerUse);
+    const auto &repair = *_services.game.skills.get(SkillType::Repair);
+    _controls.LBL_COMP_SKILL->setTextMessage(computerUse.name);
+    _controls.LBL_REP_SKILL->setTextMessage(repair.name);
+    if (isTSL()) {
+        return;
+    }
+    _controls.LBL_COMP_SKILL_ICON->setBorderFill(computerUse.icon);
+    _controls.LBL_REP_SKILL_ICON->setBorderFill(repair.icon);
+}
+
+void ComputerGUI::configureBands() {
+    if (isTSL()) {
         return;
     }
+    for (const auto &band : {_controls.LBL_STATIC1, _controls.LBL_STATIC2, _controls.LBL_STATIC3, _controls.LBL_STATIC4}) {
+        band->setBorderAlpha(kStaticBandAlpha);
+    }
+}
 
-    // K1 computer.gui ships static band overlays that duplicate the terminal background.
-    setVisible(_controls.LBL_STATIC1, false);
-    setVisible(_controls.LBL_STATIC2, false);
-    setVisible(_controls.LBL_STATIC3, false);
-    setVisible(_controls.LBL_STATIC4, false);
+void ComputerGUI::loadPanelFrames() {
+    const auto types = getRequiredTwoDA(_services.resource.twoDas, kComputerTypesResRef);
+    _panelFrames.clear();
+    for (int row = 0; row < types->getRowCount(); ++row) {
+        _panelFrames.push_back(types->getString(row, "computerbackground"));
+    }
+}
+
+void ComputerGUI::applyPanelFrame() {
+    if (isTSL()) {
+        return;
+    }
+    // A computer type without a row in comptypes.2da takes the first row's
+    // frame.
+    const auto type = static_cast<size_t>(_dialog->computerType);
+    _gui->rootControl().setBorderFill(_panelFrames.at(type < _panelFrames.size() ? type : 0));
+}
+
+void ComputerGUI::refreshSkills() {
+    const auto leader = _game.party().getLeader();
+    int spikes = 0;
+    int parts = 0;
+    for (const auto &item : _game.party().sharedInventoryReceiver(leader)->items()) {
+        if (item->tag() == kComputerSpikeTag) {
+            spikes += item->stackSize();
+        } else if (item->tag() == kRepairPartTag) {
+            parts += item->stackSize();
+        }
+    }
+    _controls.LBL_COMP_SKILL_VAL->setTextMessage(std::to_string(leader->getUnopposedSkillRank(SkillType::ComputerUse)));
+    _controls.LBL_REP_SKILL_VAL->setTextMessage(std::to_string(leader->getUnopposedSkillRank(SkillType::Repair)));
+    _controls.LBL_COMP_SPIKES_VAL->setTextMessage(std::to_string(spikes));
+    _controls.LBL_REP_UNITS_VAL->setTextMessage(std::to_string(parts));
 }
 
 void ComputerGUI::setMessage(std::string message) {
@@ -147,6 +236,9 @@ void ComputerGUI::setReplyLines(std::vector<std::string> lines) {
         item.text = lines[i];
         _controls.LB_REPLIES->addItem(std::move(item));
     }
+    // The numbers are written once per entry, when its replies are listed,
+    // so they show what the entry's reply conditions leave.
+    refreshSkills();
 }
 
 } // namespace game
diff --git a/src/libs/gui/control.cpp b/src/libs/gui/control.cpp
index 4d2c40155..c0aa23966 100644
--- a/src/libs/gui/control.cpp
+++ b/src/libs/gui/control.cpp
@@ -288,7 +288,7 @@ void Control::renderBorder(const Border &border,
                 *border.fill,
                 {_extent.left + leftWidth + offset.x, _extent.top + topHeight + offset.y},
                 fillSize,
-                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), _borderFillOpacity),
+                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), _borderFillOpacity * border.alpha),
                 uv,
                 _sharpenBorderFillAlpha ? ImageAlphaMode::Sharpen : ImageAlphaMode::Default);
         });
@@ -311,7 +311,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y},
                 {leftWidth, height},
-                glm::vec4(color, 1.0f),
+                glm::vec4(color, border.alpha),
                 uv);
 
             // Right edge
@@ -323,7 +323,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x + size.x - rightWidth, y},
                 {rightWidth, height},
-                glm::vec4(color, 1.0f),
+                glm::vec4(color, border.alpha),
                 uv);
         }
 
@@ -336,7 +336,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y},
                 {width, topHeight},
-                glm::vec4(color, 1.0f));
+                glm::vec4(color, border.alpha));
 
             // Bottom edge
             uv = glm::mat3x4(
@@ -347,7 +347,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y + size.y - bottomHeight},
                 {width, bottomHeight},
-                glm::vec4(color, 1.0f),
+                glm::vec4(color, border.alpha),
                 uv);
         }
     }
@@ -361,7 +361,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x, y},
             {leftWidth, topHeight},
-            glm::vec4(color, 1.0f));
+            glm::vec4(color, border.alpha));
 
         // Bottom left corner
         uv = glm::mat3x4(
@@ -372,7 +372,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x, y + size.y - bottomHeight},
             {leftWidth, bottomHeight},
-            glm::vec4(color, 1.0f),
+            glm::vec4(color, border.alpha),
             uv);
 
         // Top right corner
@@ -384,7 +384,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x + size.x - rightWidth, y},
             {rightWidth, topHeight},
-            glm::vec4(color, 1.0f),
+            glm::vec4(color, border.alpha),
             uv);
 
         // Bottom right corner
@@ -396,7 +396,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x + size.x - rightWidth, y + size.y - bottomHeight},
             {rightWidth, bottomHeight},
-            glm::vec4(color, 1.0f),
+            glm::vec4(color, border.alpha),
             uv);
     }
 }
@@ -622,6 +622,10 @@ void Control::setBorderColor(glm::vec3 color) {
     _border->color = std::move(color);
 }
 
+void Control::setBorderAlpha(float alpha) {
+    _border->alpha = alpha;
+}
+
 void Control::setBorderColorOverride(glm::vec3 color) {
     _borderColorOverride = std::move(color);
 }
diff --git a/test/game/computer.cpp b/test/game/computer.cpp
index 3dd976a3a..d6a17ce5a 100644
--- a/test/game/computer.cpp
+++ b/test/game/computer.cpp
@@ -127,6 +127,13 @@ class ComputerGUITest : public TestWithParam<GameID> {
                 preload(*camera);
                 return camera;
             }));
+        if (GetParam() == GameID::KotOR) {
+            // The KotOR terminal frames its panel from comptypes.2da.
+            std::shared_ptr<TwoDA> computerTypes(TwoDA::Builder().columns({"label", "computerbackground"}).row({"Standard", "panel01"}).build());
+            ON_CALL(engine.resourceModule().twoDas(), get(std::string("comptypes"))).WillByDefault(Return(computerTypes));
+            panel = std::make_shared<Label>(*normal, svc.scene.graphs, svc.graphics, svc.resource);
+            ON_CALL(*normal, rootControl()).WillByDefault(ReturnRef(*panel));
+        }
         computer = std::make_unique<TestComputer>(*game, svc);
         computer->init();
     }
@@ -145,6 +152,7 @@ class ComputerGUITest : public TestWithParam<GameID> {
     std::shared_ptr<NiceMock<MockGUI>> normal;
     std::shared_ptr<NiceMock<MockGUI>> camera;
     std::shared_ptr<Label> returnControl;
+    std::shared_ptr<Label> panel;
     std::unique_ptr<TestComputer> computer;
 };
 

From 9913eb30f7e4f6309220fa15d1888bec95414179 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:28:06 -0400
Subject: [PATCH 02/23] The experience a creature's next level needs is
 exptable.2da's XP at row = level, read as 32 unsigned bits and compared
 unsigned. It decides when a level-up is due, how far the experience reaches
 (TSL's G_PC_LEVEL, the auto level-up), the level-up notice and the character
 sheet, which hides the amount at the title's maximum level. AddMultiClass's
 award counts, in KotOR, up to the first row the experience falls short of,
 from the first row; in TSL from the levels taken.

Adding experience never lowers it: a negative amount, or one that would pass
the most an int holds, changes nothing, so a TSL companion made a Jedi
while a level-up is due keeps its experience and only its joining
experience drops.

The controlled character's HUD portrait opens the character sheet while
a level-up is due, the equipment otherwise
---
 include/reone/game/game.h              |  6 +-
 include/reone/game/object/creature.h   | 35 ++++++---
 src/libs/game/game.cpp                 | 23 ++++--
 src/libs/game/gui/hud.cpp              |  5 +-
 src/libs/game/gui/ingame/character.cpp |  9 ++-
 src/libs/game/modulesnapshot.cpp       |  2 +-
 src/libs/game/object/creature.cpp      | 98 +++++++++++++++-----------
 test/fixtures/engine.h                 | 34 ++++++++-
 8 files changed, 149 insertions(+), 63 deletions(-)

diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 54ef2ea34..0b6294ae9 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -584,7 +584,8 @@ class Game : boost::noncopyable {
     StatusSummaryAccumulator &statusSummary() { return _statusSummary; }
     /**
      * A status summary was taken down or passed by unseen. TSL then looks for
-     * the story's reaction to the player character's alignment.
+     * the story's reaction to the player character's alignment, and, the first
+     * time the player's own character can level up, runs the level-up dialog.
      */
     void finishStatusSummaryCycle();
 
@@ -1946,6 +1947,9 @@ class Game : boost::noncopyable {
                               std::optional<std::reference_wrapper<const Creature>> subject, bool hideActions,
                               bool &hidden) const;
 
+    /** TSL: runs the level-up dialog script the first time only. */
+    void runLevelUpDialogOnce();
+
     void advanceWorldTime(double dt);
     void advanceTimeStopClock(double dt);
     void advancePlayedTime(float dt);
diff --git a/include/reone/game/object/creature.h b/include/reone/game/object/creature.h
index 32d1ce784..eb9c854a6 100644
--- a/include/reone/game/object/creature.h
+++ b/include/reone/game/object/creature.h
@@ -22,6 +22,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <limits>
 #include <optional>
 #include <vector>
 
@@ -330,6 +331,8 @@ class Creature : public Object, public scene::IAnimationEventListener {
 public:
     /** The Fury damage bonus of a creature that is not in a Fury. */
     static constexpr int kNoFuryDamageBonus = -1;
+    /** The most experience a creature holds; an addition past it is refused. */
+    static constexpr int kMaxExperience = std::numeric_limits<int>::max();
 
     // AI state
 
@@ -571,9 +574,10 @@ class Creature : public Object, public scene::IAnimationEventListener {
     /**
      * Adds experience. With two or more classes, every class other than the
      * favoured one that is two or more levels below the highest of those
-     * classes takes a fifth of the amount, rounded down; the amount counts as
-     * unsigned. A race without a favoured class favours the highest-level
-     * class, the earliest on a tie.
+     * classes takes a fifth of the amount, rounded down. A race without a
+     * favoured class favours the highest-level class, the earliest on a tie.
+     * Experience only grows: a negative amount, or one that would take it
+     * past kMaxExperience, changes nothing.
      */
     void giveXP(int amount);
     void setXP(int xp);
@@ -771,21 +775,30 @@ class Creature : public Object, public scene::IAnimationEventListener {
      * nor a party member at zero vitality.
      */
     bool clicksTriggerInReach(const Object &target) const;
-    /** Enough experience for the next level, below the title's maximum, neither dead nor downed. */
+    /**
+     * Enough experience for the next level by the experience table, below the
+     * title's maximum, neither dead nor downed.
+     */
     bool isLevelUpPending() const;
     /** The level-up chime may still sound for the creature: from its creation, and again after each level-up. */
     bool isLevelUpChimeArmed() const { return _levelUpChimeArmed; }
     void setLevelUpChimeArmed(bool armed) { _levelUpChimeArmed = armed; }
-    /** The level the creature's experience reaches, up to the title's maximum. */
+    /** The level the creature's experience reaches by the experience table, up to the title's maximum. */
     int potentialLevel() const;
 
     glm::vec3 getSelectablePosition() const override;
-    int getNeededXP() const;
     /**
-     * The experience the creature lacks for its next level: KotOR counts from
-     * the level its experience reaches, TSL from the levels it has taken,
-     * scaled as an autobalanced creature's. At the title's maximum level, the
-     * unreachable amount less the experience held, which is negative.
+     * The experience the creature's level needs for the next, from the
+     * experience table; none at or past the title's maximum level.
+     */
+    std::optional<uint32_t> getNeededXP() const;
+    /**
+     * The experience the creature lacks for its next level, from the
+     * experience table: KotOR up to the first row its experience falls short
+     * of, counted from the first row; TSL from the levels it has taken,
+     * scaled as an autobalanced creature's, a level past the table reading
+     * the maximum level's row. The difference wraps as 32 bits, so it is
+     * negative when the creature has more, as at the maximum level.
      */
     int experienceToNextLevel() const;
 
@@ -2385,7 +2398,7 @@ class Creature : public Object, public scene::IAnimationEventListener {
     bool _leftEncounter {false};
     uint32_t _orientationLock {script::kObjectInvalid};
     bool _engagedExchange {false};
-    uint32_t _xp {0};
+    int _xp {0};
     bool _levelUpChimeArmed {true};
     int _joiningXP {0};
     CombatForm _currentForm {CombatForm::None};
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 2de08bf20..3e0351bc5 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -8375,13 +8375,19 @@ void Game::notifyLevelUpAvailable(const Creature &creature, bool newlyAvailable)
     }
     // TSL introduces levelling up the first time the player character can,
     // outside a conversation.
-    if (isTSL() && creature.isPlayerCreated() && !isConversationActive() &&
-        getGlobalNumber(kLevelUpDialogFiredGlobal) == 0) {
-        setGlobalNumber(kLevelUpDialogFiredGlobal, 1);
-        _scriptRunner->run(kLevelUpDialogScript);
+    if (isTSL() && creature.isPlayerCreated() && !isConversationActive()) {
+        runLevelUpDialogOnce();
     }
 }
 
+void Game::runLevelUpDialogOnce() {
+    if (getGlobalNumber(kLevelUpDialogFiredGlobal) != 0) {
+        return;
+    }
+    setGlobalNumber(kLevelUpDialogFiredGlobal, 1);
+    _scriptRunner->run(kLevelUpDialogScript);
+}
+
 /** The name character generation loads under. */
 static constexpr char kClassSelectionLoadScreen[] = "classsel";
 
@@ -8650,8 +8656,13 @@ void Game::submitStatusSummary(
 
 void Game::finishStatusSummaryCycle() {
     static constexpr char kAlignmentMovieScript[] = "k_align_movie";
-    if (isTSL()) {
-        _scriptRunner->run(kAlignmentMovieScript);
+    if (!isTSL()) {
+        return;
+    }
+    _scriptRunner->run(kAlignmentMovieScript);
+    const auto &player = *_party.player();
+    if (player.isPlayerCreated() && player.isLevelUpPending()) {
+        runLevelUpDialogOnce();
     }
 }
 
diff --git a/src/libs/game/gui/hud.cpp b/src/libs/game/gui/hud.cpp
index e5156b9be..874378265 100644
--- a/src/libs/game/gui/hud.cpp
+++ b/src/libs/game/gui/hud.cpp
@@ -472,7 +472,10 @@ void HUD::onGUILoaded() {
             _actionBar.usePartyItemOn(0);
             return;
         }
-        _game.openInGameMenu(InGameMenuTab::Equipment);
+        // The controlled character's portrait opens the character sheet
+        // while a level-up is due, the equipment otherwise.
+        const bool levelUp = _game.party().getLeader()->isLevelUpPending();
+        _game.openInGameMenu(levelUp ? InGameMenuTab::Character : InGameMenuTab::Equipment);
     });
     // Otherwise a member who is down cannot take control.
     auto selectMember = [this](int portrait) {
diff --git a/src/libs/game/gui/ingame/character.cpp b/src/libs/game/gui/ingame/character.cpp
index 45269bc66..8add4fa4e 100644
--- a/src/libs/game/gui/ingame/character.cpp
+++ b/src/libs/game/gui/ingame/character.cpp
@@ -320,7 +320,14 @@ void CharacterMenu::refreshControls() {
     _controls.LBL_WILL_STAT->setTextMessage(std::to_string(savingThrows.will));
 
     _controls.LBL_EXPERIENCE_STAT->setTextMessage(std::to_string(partyLeader->xp()));
-    _controls.LBL_NEEDED_XP->setTextMessage(std::to_string(partyLeader->getNeededXP()));
+    // Past the title's level cap the experience the next level needs is
+    // hidden.
+    const auto needed = partyLeader->getNeededXP();
+    if (needed) {
+        _controls.LBL_NEEDED_XP->setTextMessage(std::to_string(*needed));
+    }
+    _controls.LBL_NEEDED_XP->setVisible(needed.has_value());
+    _controls.LBL_NEXT_LEVEL->setVisible(needed.has_value());
 
     if (_game.isTSL()) {
         refreshForceMastery(*partyLeader);
diff --git a/src/libs/game/modulesnapshot.cpp b/src/libs/game/modulesnapshot.cpp
index fa80c6b79..15cdc4835 100644
--- a/src/libs/game/modulesnapshot.cpp
+++ b/src/libs/game/modulesnapshot.cpp
@@ -1156,7 +1156,7 @@ void ModuleSnapshotBuilder::writeCreatureState(Gff &record, const Creature &crea
     if (_game.isTSL()) {
         put(record, Gff::Field::newInt("BonusForcePoints", creature._bonusForcePoints));
     }
-    put(record, Gff::Field::newDword("Experience", creature._xp));
+    put(record, Gff::Field::newDword("Experience", static_cast<uint32_t>(creature._xp)));
     put(record, Gff::Field::newInt("JoiningXP", creature._joiningXP));
     put(record, Gff::Field::newByte("GoodEvil", creature._goodEvil));
     // A field label holds sixteen characters, so the base alignment's is cut short.
diff --git a/src/libs/game/object/creature.cpp b/src/libs/game/object/creature.cpp
index 394d1a892..2eda10209 100644
--- a/src/libs/game/object/creature.cpp
+++ b/src/libs/game/object/creature.cpp
@@ -5524,39 +5524,48 @@ static int maxCharacterLevel(bool tsl) {
     return tsl ? 50 : 20;
 }
 
-/** The experience threshold of the maximum level, which no experience reaches. */
-static constexpr uint32_t kUnreachableExperience = 0xffffffff;
-
-// The experience a character needs to rise past the level.
-static int levelExperienceThreshold(int level) {
-    return level * (level + 1) * 500;
-}
-
+// The experience table's row is the level; experience and the table's
+// amounts compare unsigned.
 bool Creature::isLevelUpPending() const {
-    return _attributes.getAggregateLevel() < maxCharacterLevel(_game.isTSL()) &&
-           static_cast<int>(_xp) >= getNeededXP() && !isDead() && !isTemporarilyDead();
+    if (isDead() || isTemporarilyDead()) {
+        return false;
+    }
+    const auto needed = getNeededXP();
+    return needed && static_cast<uint32_t>(_xp) >= *needed;
 }
 
 int Creature::potentialLevel() const {
+    const auto &tables = _services.game.combatTables;
     int level = _attributes.getAggregateLevel();
-    while (level < maxCharacterLevel(_game.isTSL()) && static_cast<int>(_xp) >= levelExperienceThreshold(level)) {
+    while (level < maxCharacterLevel(_game.isTSL()) &&
+           static_cast<uint32_t>(_xp) >= tables.experienceThreshold(level)) {
         ++level;
     }
     return level;
 }
 
-int Creature::getNeededXP() const {
-    return levelExperienceThreshold(_attributes.getAggregateLevel());
+std::optional<uint32_t> Creature::getNeededXP() const {
+    const int level = _attributes.getAggregateLevel();
+    if (level >= maxCharacterLevel(_game.isTSL())) {
+        return std::nullopt;
+    }
+    return _services.game.combatTables.experienceThreshold(level);
 }
 
 int Creature::experienceToNextLevel() const {
-    const bool tsl = _game.isTSL();
-    const int level = tsl ? getSpellLevel(false) : potentialLevel();
-    if (level >= maxCharacterLevel(tsl)) {
-        // The threshold of the maximum level is the unreachable amount.
-        return static_cast<int>(kUnreachableExperience - _xp);
+    const auto &tables = _services.game.combatTables;
+    const auto xp = static_cast<uint32_t>(_xp);
+    if (_game.isTSL()) {
+        const int level = std::min(getSpellLevel(false), maxCharacterLevel(true));
+        return static_cast<int>(tables.experienceThreshold(level) - xp);
+    }
+    for (int row = 0; row <= maxCharacterLevel(false); ++row) {
+        const uint32_t threshold = tables.experienceThreshold(row);
+        if (xp < threshold) {
+            return static_cast<int>(threshold - xp);
+        }
     }
-    return levelExperienceThreshold(level) - static_cast<int>(_xp);
+    return static_cast<int>(0u - xp);
 }
 
 void Creature::runSpawnScript() {
@@ -5629,32 +5638,38 @@ void Creature::runConversationScript() {
     _game.scriptRunner().run(_onDialogue, _id);
 }
 
+// An addition that would lower the experience, or pass the most it holds,
+// is refused.
 void Creature::giveXP(int amount) {
-    const auto &classes = _attributes.classLevels();
-    if (classes.size() < 2) {
-        setXP(_xp + amount);
+    if (amount < 0) {
         return;
     }
-    int favored = race().favoredClass;
-    if (favored == kNoFavoredClass) {
-        const auto highest = std::max_element(classes.begin(), classes.end(),
-                                              [](const auto &a, const auto &b) { return a.second < b.second; });
-        favored = static_cast<int>(highest->first->type());
-    }
-    int highestLevel = 0;
-    for (const auto &[clazz, level] : classes) {
-        if (static_cast<int>(clazz->type()) != favored) {
-            highestLevel = std::max(highestLevel, level);
-        }
-    }
+    const auto &classes = _attributes.classLevels();
     int behind = 0;
-    for (const auto &[clazz, level] : classes) {
-        if (static_cast<int>(clazz->type()) != favored && highestLevel - level >= 2) {
-            ++behind;
+    if (classes.size() >= 2) {
+        int favored = race().favoredClass;
+        if (favored == kNoFavoredClass) {
+            const auto highest = std::max_element(classes.begin(), classes.end(),
+                                                  [](const auto &a, const auto &b) { return a.second < b.second; });
+            favored = static_cast<int>(highest->first->type());
+        }
+        int highestLevel = 0;
+        for (const auto &[clazz, level] : classes) {
+            if (static_cast<int>(clazz->type()) != favored) {
+                highestLevel = std::max(highestLevel, level);
+            }
+        }
+        for (const auto &[clazz, level] : classes) {
+            if (static_cast<int>(clazz->type()) != favored && highestLevel - level >= 2) {
+                ++behind;
+            }
         }
     }
-    const int64_t kept = int64_t {static_cast<uint32_t>(amount)} * (5 - behind) / 5;
-    setXP(_xp + static_cast<uint32_t>(kept));
+    const auto kept = static_cast<int>(int64_t {amount} * (5 - behind) / 5);
+    if (kept > kMaxExperience - _xp) {
+        return;
+    }
+    setXP(_xp + kept);
 }
 
 void Creature::setXP(int xp) {
@@ -10423,7 +10438,10 @@ void Creature::deserializeAll(
     if (gff.readInt(aiStyle, "AIState")) {
         _aiStyle = static_cast<NPCAIStyle>(aiStyle);
     }
-    gff.readDword(_xp, "Experience");
+    uint32_t experience {0};
+    if (gff.readDword(experience, "Experience")) {
+        _xp = static_cast<int>(experience);
+    }
     gff.readInt(_joiningXP, "JoiningXP");
 
     gff.readResRef(_onNotice, "ScriptOnNotice");
diff --git a/test/fixtures/engine.h b/test/fixtures/engine.h
index 44e0cef0b..f17acea3e 100644
--- a/test/fixtures/engine.h
+++ b/test/fixtures/engine.h
@@ -98,7 +98,7 @@ class TestEngine : boost::noncopyable {
         ON_CALL(_resourceModule->twoDas(), get(std::string("racialtypes"))).WillByDefault(testing::Return(racialTypes));
         _gameModule->races().init(_resourceModule->twoDas());
         // The combat tables the game loads at start, with no rows but an
-        // excitement of no duration.
+        // excitement of no duration and KotOR's experience table.
         testing::NiceMock<resource::MockTwoDAs> combatTables;
         ON_CALL(combatTables, get(testing::_)).WillByDefault(testing::Invoke(&TestEngine::defaultCombatTable));
         _gameModule->combatTables().init(combatTables, resource::GameID::KotOR);
@@ -166,11 +166,41 @@ class TestEngine : boost::noncopyable {
     /** The rows of racialtypes.2da a creature may name. */
     static constexpr int kRacialTypeCount = 9;
 
-    /** A combat table as the game loads it at start: no rows, but an excitement of no duration. */
+    /**
+     * A combat table as the game loads it at start: no rows, but an excitement
+     * of no duration and KotOR's experience table, which also covers the TSL
+     * levels the tests reach.
+     */
     static std::shared_ptr<resource::TwoDA> defaultCombatTable(const std::string &resRef) {
         if (resRef == "excitedduration") {
             return resource::TwoDA::Builder().columns({"duration"}).row({"0"}).row({"0"}).row({"0"}).build();
         }
+        if (resRef == "exptable") {
+            return resource::TwoDA::Builder()
+                .columns({"level", "xp"})
+                .row({"1", "0"})
+                .row({"2", "1000"})
+                .row({"3", "3000"})
+                .row({"4", "6000"})
+                .row({"5", "10000"})
+                .row({"6", "15000"})
+                .row({"7", "21000"})
+                .row({"8", "28000"})
+                .row({"9", "36000"})
+                .row({"10", "45000"})
+                .row({"11", "55000"})
+                .row({"12", "66000"})
+                .row({"13", "78000"})
+                .row({"14", "91000"})
+                .row({"15", "105000"})
+                .row({"16", "120000"})
+                .row({"17", "136000"})
+                .row({"18", "153000"})
+                .row({"19", "171000"})
+                .row({"20", "190000"})
+                .row({"21", "0xFFFFFFFF"})
+                .build();
+        }
         return resource::TwoDA::Builder().build();
     }
 

From 7c35ff4c8da7ede5c9bbb886cc31443615f8e057 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:29:20 -0400
Subject: [PATCH 03/23] One pulse, shared by every GUI and advanced in real
 time, replaces the opacity of pulsing frames, fills and texts, as layouts and
 screens ask. The abilities screen's selected skill row pulses as in each
 game, and the charts' chosen node pulses alone on the shared pulse.

---
 include/reone/gui/control.h             | 22 +++++++++++-
 include/reone/gui/control/iconchain.h   |  3 --
 include/reone/gui/control/imagebutton.h | 13 +++++++
 include/reone/gui/gui.h                 | 48 +++++++++++++++++++++++--
 include/reone/gui/guis.h                |  9 +++++
 src/libs/game/game.cpp                  |  3 ++
 src/libs/game/gui/ingame/abilities.cpp  | 22 ++++++++----
 src/libs/gui/control.cpp                | 43 ++++++++++++++++------
 src/libs/gui/control/iconchain.cpp      | 34 +++++++-----------
 src/libs/gui/control/imagebutton.cpp    | 10 +++++-
 src/libs/gui/guis.cpp                   |  2 +-
 test/fixtures/gui.h                     |  2 ++
 test/fixtures/itempresentation.h        |  4 ++-
 test/game/object.cpp                    | 15 +++++---
 14 files changed, 177 insertions(+), 53 deletions(-)

diff --git a/include/reone/gui/control.h b/include/reone/gui/control.h
index 90b5098c3..893a4d42b 100644
--- a/include/reone/gui/control.h
+++ b/include/reone/gui/control.h
@@ -100,6 +100,10 @@ class Control : boost::noncopyable {
         float alpha {1.0f};
         int dimension {0};
         FillTransform fillTransform {FillTransform::None};
+        /** While set, the corners and edges are drawn at the GUI's pulsing alpha instead of alpha. */
+        bool pulseFrame {false};
+        /** While set, the fill is drawn at the GUI's pulsing alpha instead of alpha. */
+        bool pulseFill {false};
     };
 
     struct Text {
@@ -108,6 +112,10 @@ class Control : boost::noncopyable {
         glm::vec3 color {1.0f};
         TextAlign align {TextAlign::CenterCenter};
         float opacity {1.0f};
+        /** The text is drawn at the GUI's pulsing alpha. */
+        bool pulsing {false};
+        /** While the control is selected, the text is drawn at the GUI's pulsing alpha. */
+        bool hilightPulsing {false};
     };
 
     static ControlType getType(const resource::generated::GUI_BASECONTROL &gui);
@@ -189,6 +197,10 @@ class Control : boost::noncopyable {
     void setText(Text text);
     void setTextAlignment(TextAlign align);
     void setTextColor(glm::vec3 color);
+    /** While selected, the text is drawn at the GUI's pulsing alpha. */
+    void setHilightTextPulsing(bool pulsing) { _text.hilightPulsing = pulsing; }
+    /** The hilight's frame and fill pulse, as chosen. */
+    void setHilightPulsing(bool frame, bool fill);
     /** Sets the alpha the text is drawn with. */
     void setTextOpacity(float opacity) { _text.opacity = opacity; }
     void setTextMessage(std::string text);
@@ -301,11 +313,19 @@ class Control : boost::noncopyable {
         _resourceSvc(resourceSvc) {
     }
 
+    /**
+     * Draws a border over the given size.
+     *
+     * @param part the parts of the border drawn
+     * @param pulsing whether the whole border is drawn at the GUI's pulsing
+     *                alpha, whatever the border's own pulse
+     */
     void renderBorder(const Border &border,
                       const glm::ivec2 &offset,
                       const glm::ivec2 &size,
                       scene::IRenderPass &pass,
-                      BorderRenderPart part = BorderRenderPart::All);
+                      BorderRenderPart part = BorderRenderPart::All,
+                      bool pulsing = false);
 
     void renderScene(const glm::ivec2 &screenSize,
                      const glm::ivec2 &offset,
diff --git a/include/reone/gui/control/iconchain.h b/include/reone/gui/control/iconchain.h
index 41e799840..ae946d64f 100644
--- a/include/reone/gui/control/iconchain.h
+++ b/include/reone/gui/control/iconchain.h
@@ -100,7 +100,6 @@ class IconChain : public Control {
     bool handleMouseMotion(int x, int y) override;
     bool handleMouseWheel(int x, int y) override;
     bool handleClick(int x, int y, int clicks = 1) override;
-    void update(float dt) override;
     void render(const glm::ivec2 &screenSize, const glm::ivec2 &offset, scene::IRenderPass &pass) override;
     void setSelected(bool selected) override;
 
@@ -134,7 +133,6 @@ class IconChain : public Control {
     CellStyle _cellStyle;
     int _rowOffset {0};
     int _focusedItemIndex {-1};
-    float _focusedBorderPulsePhase {0.0f};
 
     // Event listeners
 
@@ -162,7 +160,6 @@ class IconChain : public Control {
     glm::vec3 getItemBorderColor(const Item &item, bool focused) const;
     glm::vec4 getItemIconColor(const Item &item) const;
     std::optional<glm::vec3> getFocusedBorderColor(const Item &item, bool focused) const;
-    float getFocusedBorderPulseFactor() const;
     void renderLink(
         const Link &link,
         const glm::ivec2 &offset,
diff --git a/include/reone/gui/control/imagebutton.h b/include/reone/gui/control/imagebutton.h
index 0a13d31bb..8a7613f7d 100644
--- a/include/reone/gui/control/imagebutton.h
+++ b/include/reone/gui/control/imagebutton.h
@@ -50,7 +50,20 @@ class ImageButton : public Control {
         const std::shared_ptr<graphics::Texture> &iconFrame,
         scene::IRenderPass &pass);
 
+    /**
+     * While selected, the icon frame takes this colour (unset, the hilight's)
+     * and, if pulsing, the GUI's pulsing alpha.
+     */
+    void setIconFrameHilight(std::optional<glm::vec3> color, bool pulsing) {
+        _iconFrameHilightColor = std::move(color);
+        _iconFrameHilightPulsing = pulsing;
+    }
+
 private:
+    /** The selected icon frame's colour; unset, the hilight's. */
+    std::optional<glm::vec3> _iconFrameHilightColor;
+    /** Whether the selected icon frame is drawn at the GUI's pulsing alpha. */
+    bool _iconFrameHilightPulsing {false};
     std::shared_ptr<graphics::Texture> _iconFrame;
     std::shared_ptr<graphics::Font> _iconFont;
 
diff --git a/include/reone/gui/gui.h b/include/reone/gui/gui.h
index bcaf95884..ff9ba5557 100644
--- a/include/reone/gui/gui.h
+++ b/include/reone/gui/gui.h
@@ -49,6 +49,40 @@ class IGUIEventListener {
     virtual void onSelectionChanged(const std::string &control, bool selected) = 0;
 };
 
+/**
+ * The opacity shared by every pulsing border, image and text: it falls from 1
+ * to 0.4 over 0.75 s, rises back over the next 0.75 s, and repeats.
+ */
+class PulsingAlpha {
+public:
+    /** Advances the pulse by dt seconds of real time. */
+    void update(float dt) {
+        _timeLeft -= dt;
+        if (_timeLeft <= 0.0f) {
+            _rising = !_rising;
+            _timeLeft = kHalfPeriod;
+        }
+        const float progress = (kHalfPeriod - _timeLeft) / kHalfPeriod;
+        _value = _rising ? kLow + (1.0f - kLow) * progress : 1.0f - (1.0f - kLow) * progress;
+    }
+
+    /** The opacity now, 0.4 to 1. */
+    float value() const { return _value; }
+
+private:
+    /** Seconds the pulse takes to fall, or to rise. */
+    static constexpr float kHalfPeriod = 0.75f;
+    /** The opacity at the bottom of the pulse. */
+    static constexpr float kLow = 0.4f;
+
+    /** The opacity now. */
+    float _value {1.0f};
+    /** Seconds left before the pulse turns. */
+    float _timeLeft {kHalfPeriod};
+    /** Whether the opacity is rising; it starts falling from 1. */
+    bool _rising {false};
+};
+
 class IGUI {
 public:
     enum class ScalingMode {
@@ -101,6 +135,8 @@ class IGUI {
     virtual float borderScale() const = 0;
     virtual float listScale() const = 0;
     virtual bool tintBorderFills() const = 0;
+    /** The opacity pulsing borders and texts are drawn with now. */
+    virtual float pulsingAlpha() const = 0;
 
     /** Whether scene-backed controls may render their 3D content. */
     virtual bool sceneRenderEnabled() const = 0;
@@ -130,12 +166,13 @@ class GUI : public IGUI, boost::noncopyable {
         graphics::GraphicsOptions &options,
         scene::ISceneGraphs &sceneGraphs,
         graphics::GraphicsServices &graphicsSvc,
-        resource::ResourceServices &resourceSvc) :
+        resource::ResourceServices &resourceSvc,
+        const PulsingAlpha &pulsingAlpha) :
         _options(options),
         _sceneGraphs(sceneGraphs),
         _graphicsSvc(graphicsSvc),
-        _resourceSvc(resourceSvc) {
-
+        _resourceSvc(resourceSvc),
+        _pulsingAlpha(pulsingAlpha) {
     }
 
     /** Derived from the current resolution, which can change at runtime. */
@@ -220,6 +257,10 @@ class GUI : public IGUI, boost::noncopyable {
         return _tintBorderFills;
     }
 
+    float pulsingAlpha() const override {
+        return _pulsingAlpha.value();
+    }
+
     bool sceneRenderEnabled() const override {
         return _options.sceneRender;
     }
@@ -278,6 +319,7 @@ class GUI : public IGUI, boost::noncopyable {
     scene::ISceneGraphs &_sceneGraphs;
     graphics::GraphicsServices &_graphicsSvc;
     resource::ResourceServices &_resourceSvc;
+    const PulsingAlpha &_pulsingAlpha;
 
     // END Services
 
diff --git a/include/reone/gui/guis.h b/include/reone/gui/guis.h
index 56a516250..0c87fb5a1 100644
--- a/include/reone/gui/guis.h
+++ b/include/reone/gui/guis.h
@@ -36,6 +36,9 @@ class IGUIs {
     virtual void clear() = 0;
 
     virtual std::shared_ptr<IGUI> get(const std::string &resRef, std::function<void(IGUI &)> preload = nullptr) = 0;
+
+    /** Advances the pulse every GUI shares, once a frame, by real time. */
+    virtual void updatePulsingAlpha(float dt) = 0;
 };
 
 class GUIs : public IGUIs, boost::noncopyable {
@@ -63,12 +66,18 @@ class GUIs : public IGUIs, boost::noncopyable {
         return _guis.insert(make_pair(resRef, std::move(gui))).first->second;
     }
 
+    void updatePulsingAlpha(float dt) override {
+        _pulsingAlpha.update(dt);
+    }
+
 private:
     graphics::GraphicsOptions &_graphicsOpt;
     scene::ISceneGraphs &_sceneGraphs;
     graphics::GraphicsServices &_graphicsSvc;
     resource::ResourceServices &_resourceSvc;
 
+    /** The pulse every GUI shares; declared before the GUIs that hold it, so it outlives them. */
+    PulsingAlpha _pulsingAlpha;
     std::unordered_map<std::string, std::shared_ptr<IGUI>> _guis;
 
     std::shared_ptr<IGUI> doGet(std::string resRef, std::function<void(IGUI &)> preload);
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 3e0351bc5..bec3e0af6 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -78,6 +78,7 @@
 #include "reone/graphics/texture.h"
 #include "reone/graphics/uniforms.h"
 #include "reone/gui/gui.h"
+#include "reone/gui/guis.h"
 #include "reone/movie/format/bikreader.h"
 #include "reone/resource/2da.h"
 #include "reone/resource/di/services.h"
@@ -931,6 +932,8 @@ bool Game::consumeTimingDiscontinuity() {
 }
 
 void Game::update(float frameTime) {
+    // Every GUI's pulse runs on real time, whatever the screen.
+    _services.gui.guis.updatePulsingAlpha(frameTime);
     // The death sequence sets how fast the world, its presentation and the
     // fade run this frame. A pending end keeps the death GUI up while its
     // delay lasts, then returns to the main menu once the game is not over.
diff --git a/src/libs/game/gui/ingame/abilities.cpp b/src/libs/game/gui/ingame/abilities.cpp
index 8cbc7e52c..ea5f58866 100644
--- a/src/libs/game/gui/ingame/abilities.cpp
+++ b/src/libs/game/gui/ingame/abilities.cpp
@@ -24,6 +24,7 @@
 #include "reone/game/object/creature.h"
 #include "reone/game/party.h"
 #include "reone/gui/control/button.h"
+#include "reone/gui/control/imagebutton.h"
 #include "reone/gui/control/label.h"
 #include "reone/gui/control/listbox.h"
 #include "reone/resource/di/services.h"
@@ -62,6 +63,8 @@ void AbilitiesMenu::onGUILoaded() {
     _controls.LBL_TOTALVAL->setTextMessage("");
     _controls.LBL_NAME->setTextMessage("");
 
+    // Every row is a skill's icon row.
+    auto &protoItem = static_cast<ImageButton &>(_controls.LB_ABILITY->protoItem());
     _controls.LB_DESC->setProtoMatchContent(true);
     if (_game.isTSL()) {
         fillK2SectionStrip(_controls.LBL_BAR1, _controls.LBL_BAR2);
@@ -76,12 +79,19 @@ void AbilitiesMenu::onGUILoaded() {
         _controls.LBL_NAME->setTintBorderFill(true);
         useK2ShellTitle(_controls.LBL_ABILITIES);
         enableK2ButtonBodyFill(_controls.BTN_EXIT);
-        if (auto protoItem = _controls.LB_ABILITY->protoItemOrNull()) {
-            enableK2ButtonBodyFill(*protoItem);
-            protoItem->setBorderFill("uibit_fill_2wt");
-            protoItem->setHilightFill("uibit_fill_2wt");
-            protoItem->setTintBorderFill(true);
-        }
+        enableK2ButtonBodyFill(protoItem);
+        protoItem.setBorderFill("uibit_fill_2wt");
+        protoItem.setHilightFill("uibit_fill_2wt");
+        protoItem.setTintBorderFill(true);
+    }
+    // The active row's frames pulse; TSL's text pulses too, and its icon
+    // frame is white.
+    protoItem.setHilightPulsing(true, false);
+    if (_game.isTSL()) {
+        protoItem.setHilightTextPulsing(true);
+        protoItem.setIconFrameHilight(glm::vec3 {1.0f}, true);
+    } else {
+        protoItem.setIconFrameHilight(std::nullopt, true);
     }
     _controls.LB_ABILITY->setOnItemClick([this](const std::string &item) {
         auto skill = static_cast<SkillType>(stoi(item));
diff --git a/src/libs/gui/control.cpp b/src/libs/gui/control.cpp
index c0aa23966..b8c1e3e58 100644
--- a/src/libs/gui/control.cpp
+++ b/src/libs/gui/control.cpp
@@ -41,6 +41,12 @@ namespace reone {
 
 namespace gui {
 
+// The flags of a border's or a text's PULSING field: a border's frame pulses
+// on the first and its fill on the second; a text pulses on the first.
+static constexpr int kPulsingFrameFlag = 1;
+static constexpr int kPulsingFillFlag = 2;
+static constexpr int kPulsingTextFlag = 1;
+
 ControlType Control::getType(const resource::generated::GUI_BASECONTROL &gui) {
     return static_cast<ControlType>(gui.CONTROLTYPE);
 }
@@ -125,6 +131,8 @@ std::shared_ptr<Control::Border> Control::createBorder(const resource::generated
 
     border->dimension = gui.DIMENSION;
     border->color = gui.COLOR;
+    border->pulseFrame = (gui.PULSING & kPulsingFrameFlag) != 0;
+    border->pulseFill = (gui.PULSING & kPulsingFillFlag) != 0;
     return border;
 }
 
@@ -141,6 +149,7 @@ void Control::loadText(const resource::generated::GUI_TEXT &gui) {
 
     _text.color = gui.COLOR;
     _text.align = static_cast<TextAlign>(gui.ALIGNMENT);
+    _text.pulsing = (gui.PULSING & kPulsingTextFlag) != 0;
 
     updateTextLines();
 }
@@ -257,10 +266,13 @@ void Control::renderBorder(const Border &border,
                            const glm::ivec2 &offset,
                            const glm::ivec2 &size,
                            IRenderPass &pass,
-                           BorderRenderPart part) {
+                           BorderRenderPart part,
+                           bool pulsing) {
     _graphicsSvc.context.useProgram(_graphicsSvc.shaderRegistry.get(ShaderProgramId::mvpTexture));
 
     glm::vec3 color(getBorderColor());
+    const auto frameAlpha = pulsing || border.pulseFrame ? _gui.pulsingAlpha() : border.alpha;
+    const auto fillAlpha = pulsing || border.pulseFill ? _gui.pulsingAlpha() : border.alpha;
     glm::mat4 transform(1.0f);
     glm::mat3x4 uv(1.0f);
     // Controls thinner than two authored slices - the TSL title bars - split
@@ -288,7 +300,7 @@ void Control::renderBorder(const Border &border,
                 *border.fill,
                 {_extent.left + leftWidth + offset.x, _extent.top + topHeight + offset.y},
                 fillSize,
-                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), _borderFillOpacity * border.alpha),
+                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), _borderFillOpacity * fillAlpha),
                 uv,
                 _sharpenBorderFillAlpha ? ImageAlphaMode::Sharpen : ImageAlphaMode::Default);
         });
@@ -311,7 +323,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y},
                 {leftWidth, height},
-                glm::vec4(color, border.alpha),
+                glm::vec4(color, frameAlpha),
                 uv);
 
             // Right edge
@@ -323,7 +335,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x + size.x - rightWidth, y},
                 {rightWidth, height},
-                glm::vec4(color, border.alpha),
+                glm::vec4(color, frameAlpha),
                 uv);
         }
 
@@ -336,7 +348,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y},
                 {width, topHeight},
-                glm::vec4(color, border.alpha));
+                glm::vec4(color, frameAlpha));
 
             // Bottom edge
             uv = glm::mat3x4(
@@ -347,7 +359,7 @@ void Control::renderBorder(const Border &border,
                 *border.edge,
                 {x, y + size.y - bottomHeight},
                 {width, bottomHeight},
-                glm::vec4(color, border.alpha),
+                glm::vec4(color, frameAlpha),
                 uv);
         }
     }
@@ -361,7 +373,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x, y},
             {leftWidth, topHeight},
-            glm::vec4(color, border.alpha));
+            glm::vec4(color, frameAlpha));
 
         // Bottom left corner
         uv = glm::mat3x4(
@@ -372,7 +384,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x, y + size.y - bottomHeight},
             {leftWidth, bottomHeight},
-            glm::vec4(color, border.alpha),
+            glm::vec4(color, frameAlpha),
             uv);
 
         // Top right corner
@@ -384,7 +396,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x + size.x - rightWidth, y},
             {rightWidth, topHeight},
-            glm::vec4(color, border.alpha),
+            glm::vec4(color, frameAlpha),
             uv);
 
         // Bottom right corner
@@ -396,7 +408,7 @@ void Control::renderBorder(const Border &border,
             *border.corner,
             {x + size.x - rightWidth, y + size.y - bottomHeight},
             {rightWidth, bottomHeight},
-            glm::vec4(color, border.alpha),
+            glm::vec4(color, frameAlpha),
             uv);
     }
 }
@@ -419,7 +431,8 @@ void Control::renderText(const std::vector<std::string> &lines,
 
     glm::vec3 linePosition(0.0f);
     const auto &hilight = shownHilight();
-    glm::vec4 color {(_selected && hilight) ? hilight->color : _text.color, _text.opacity};
+    const bool pulsing = _text.pulsing || (_selected && _text.hilightPulsing);
+    glm::vec4 color {(_selected && hilight) ? hilight->color : _text.color, pulsing ? _gui.pulsingAlpha() : _text.opacity};
 
     for (auto &line : lines) {
         linePosition.x = static_cast<float>(position.x + offset.x);
@@ -646,6 +659,14 @@ void Control::setHilightColor(glm::vec3 color) {
     _hilight->color = std::move(color);
 }
 
+void Control::setHilightPulsing(bool frame, bool fill) {
+    if (!_hilight) {
+        _hilight = std::make_shared<Border>();
+    }
+    _hilight->pulseFrame = frame;
+    _hilight->pulseFill = fill;
+}
+
 void Control::setHilightFill(std::string resRef) {
     std::shared_ptr<Texture> texture;
     if (!resRef.empty()) {
diff --git a/src/libs/gui/control/iconchain.cpp b/src/libs/gui/control/iconchain.cpp
index 99c9348c5..96250e710 100644
--- a/src/libs/gui/control/iconchain.cpp
+++ b/src/libs/gui/control/iconchain.cpp
@@ -29,8 +29,6 @@ namespace gui {
 
 static constexpr glm::vec3 kDarkItemColor {0.45f};
 static constexpr glm::vec3 kSelectedItemColor {1.0f};
-static constexpr float kFocusedBorderPulseCyclesPerSecond = 1.0f;
-static constexpr float kFocusedBorderPulseMinFactor = 0.55f;
 
 void IconChain::clearItems() {
     _items.clear();
@@ -125,12 +123,6 @@ bool IconChain::handleClick(int x, int y, int clicks) {
     return true;
 }
 
-void IconChain::update(float dt) {
-    Control::update(dt);
-    _focusedBorderPulsePhase += dt * kFocusedBorderPulseCyclesPerSecond;
-    _focusedBorderPulsePhase -= std::floor(_focusedBorderPulsePhase);
-}
-
 void IconChain::render(const glm::ivec2 &screenSize,
                        const glm::ivec2 &offset,
                        IRenderPass &pass) {
@@ -392,11 +384,6 @@ glm::vec4 IconChain::getItemIconColor(const Item &item) const {
     return glm::vec4(1.0f);
 }
 
-float IconChain::getFocusedBorderPulseFactor() const {
-    float wave = 0.5f - 0.5f * std::cos(glm::two_pi<float>() * _focusedBorderPulsePhase);
-    return glm::mix(kFocusedBorderPulseMinFactor, 1.0f, wave);
-}
-
 void IconChain::renderLink(
     const Link &link,
     const glm::ivec2 &offset,
@@ -498,6 +485,10 @@ void IconChain::renderItemBorder(
     if (_cellStyle.onlyDrawItemBorderWhenBright && !isItemBright(item)) {
         return;
     }
+    // A node with a focused frame has that one frame only.
+    if (getFocusedBorderColor(item, focused)) {
+        return;
+    }
 
     const std::shared_ptr<Border> &border = _cellStyle.itemBorder
                                                ? _cellStyle.itemBorder
@@ -540,15 +531,16 @@ void IconChain::renderFocusedBorder(
 
     Extent originalExtent(_extent);
     _extent = extent;
-    setBorderColorOverride(*maybeColor * getFocusedBorderPulseFactor());
+    setBorderColorOverride(*maybeColor);
     setUseBorderColorOverride(true);
-    if (_cellStyle.drawItemBorderFill || !border->fill) {
-        renderBorder(*border, offset, {extent.width, extent.height}, pass);
-    } else {
-        Border borderWithoutFill(*border);
-        borderWithoutFill.fill.reset();
-        renderBorder(borderWithoutFill, offset, {extent.width, extent.height}, pass);
-    }
+    // The focused frame pulses.
+    renderBorder(
+        *border,
+        offset,
+        {extent.width, extent.height},
+        pass,
+        _cellStyle.drawItemBorderFill ? BorderRenderPart::All : BorderRenderPart::Frame,
+        true);
     setUseBorderColorOverride(false);
     _extent = originalExtent;
 }
diff --git a/src/libs/gui/control/imagebutton.cpp b/src/libs/gui/control/imagebutton.cpp
index 3fb635f8c..1e00fac59 100644
--- a/src/libs/gui/control/imagebutton.cpp
+++ b/src/libs/gui/control/imagebutton.cpp
@@ -95,11 +95,19 @@ void ImageButton::renderIcon(
     }
 
     if (iconFrame) {
+        auto frameColor = color;
+        auto frameAlpha = 1.0f;
+        if (_selected && _hilight) {
+            frameColor = _iconFrameHilightColor.value_or(color);
+            if (_iconFrameHilightPulsing) {
+                frameAlpha = _gui.pulsingAlpha();
+            }
+        }
         pass.drawImage(
             *iconFrame,
             {offset.x + _extent.left, offset.y + _extent.top},
             {_extent.height, _extent.height},
-            glm::vec4(color, 1.0f));
+            glm::vec4 {frameColor, frameAlpha});
     }
 
     if (iconTexture) {
diff --git a/src/libs/gui/guis.cpp b/src/libs/gui/guis.cpp
index fa1017485..8ae874b56 100644
--- a/src/libs/gui/guis.cpp
+++ b/src/libs/gui/guis.cpp
@@ -31,7 +31,7 @@ std::shared_ptr<IGUI> GUIs::doGet(std::string resRef, std::function<void(IGUI &)
     if (!gff) {
         return nullptr;
     }
-    auto gui = std::make_shared<GUI>(_graphicsOpt, _sceneGraphs, _graphicsSvc, _resourceSvc);
+    auto gui = std::make_shared<GUI>(_graphicsOpt, _sceneGraphs, _graphicsSvc, _resourceSvc, _pulsingAlpha);
     if (preload) {
         preload(*gui);
     }
diff --git a/test/fixtures/gui.h b/test/fixtures/gui.h
index 1813fcbdc..b50e25f72 100644
--- a/test/fixtures/gui.h
+++ b/test/fixtures/gui.h
@@ -49,6 +49,7 @@ class MockGUI : public IGUI, boost::noncopyable {
     MOCK_METHOD(float, borderScale, (), (const override));
     float listScale() const override { return 1.0f; }
     MOCK_METHOD(bool, tintBorderFills, (), (const override));
+    MOCK_METHOD(float, pulsingAlpha, (), (const override));
     bool sceneRenderEnabled() const override { return true; }
 
     MOCK_METHOD(void, setEventListener, (IGUIEventListener & listener), (override));
@@ -72,6 +73,7 @@ class MockGUIs : public IGUIs, boost::noncopyable {
 public:
     MOCK_METHOD(void, clear, (), (override));
     MOCK_METHOD(std::shared_ptr<IGUI>, get, (const std::string &, std::function<void(IGUI &)>), (override));
+    MOCK_METHOD(void, updatePulsingAlpha, (float), (override));
 };
 
 class TestGUIModule : boost::noncopyable {
diff --git a/test/fixtures/itempresentation.h b/test/fixtures/itempresentation.h
index cca905a9f..8cf02530d 100644
--- a/test/fixtures/itempresentation.h
+++ b/test/fixtures/itempresentation.h
@@ -123,8 +123,9 @@ class ScreenResources : public IGUIs {
                     TestGraphicsModule &graphics, TestResourceModule &resources) :
         options(options), scene(scene), graphics(graphics), resources(resources) {}
     void clear() override { screens.clear(); }
+    void updatePulsingAlpha(float) override {}
     std::shared_ptr<IGUI> get(const std::string &name, std::function<void(IGUI &)> preload) override {
-        auto gui = std::make_shared<RecordingGUI>(options, scene.graphs(), graphics.services(), resources.services());
+        auto gui = std::make_shared<RecordingGUI>(options, scene.graphs(), graphics.services(), resources.services(), pulsingAlpha);
         gui->name = name;
         if (preload)
             preload(*gui);
@@ -134,6 +135,7 @@ class ScreenResources : public IGUIs {
         screens[name] = gui;
         return gui;
     }
+    PulsingAlpha pulsingAlpha;
     std::unordered_map<std::string, std::shared_ptr<RecordingGUI>> screens;
 
 private:
diff --git a/test/game/object.cpp b/test/game/object.cpp
index 04ebce212..76cfed1b9 100644
--- a/test/game/object.cpp
+++ b/test/game/object.cpp
@@ -2382,7 +2382,8 @@ TEST(TransitionPresentationLayout, should_uniformly_scale_and_top_anchor_the_aut
     graphics::GraphicsOptions options;
     options.width = 3440;
     options.height = 1440;
-    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource);
+    gui::PulsingAlpha pulsingAlpha;
+    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource, pulsingAlpha);
     guiInstance.setResolution(640, 480);
     guiInstance.setScaling(gui::GUI::ScalingMode::ScaledTopCenter);
 
@@ -2455,7 +2456,8 @@ TEST(GUIControlLayout, should_scale_text_uniformly_when_geometry_uses_different_
     options.width = 1920;
     options.height = 1080;
     options.guiTextScale = 1.25f;
-    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource);
+    gui::PulsingAlpha pulsingAlpha;
+    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource, pulsingAlpha);
     guiInstance.setResolution(640, 480);
     TestScaledControl control(guiInstance, engine);
     control.setAuthoredGeometry({20, 30, 200, 80}, 8, 8);
@@ -2486,7 +2488,8 @@ TEST(GUIInputCoordinates, should_hit_screen_positioned_controls_without_authored
     graphics::GraphicsOptions options;
     options.width = 1920;
     options.height = 1080;
-    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource);
+    gui::PulsingAlpha pulsingAlpha;
+    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource, pulsingAlpha);
     guiInstance.setResolution(640, 480);
     guiInstance.setScaling(gui::GUI::ScalingMode::PositionRelativeToCenter);
 
@@ -2562,7 +2565,8 @@ TEST(GUIScaledBorders, should_scale_border_and_hilight_dimensions_equally) {
     options.width = 1920;
     options.height = 1080;
     options.guiBorderScale = 1.25f;
-    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource);
+    gui::PulsingAlpha pulsingAlpha;
+    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource, pulsingAlpha);
     guiInstance.setResolution(800, 600);
     guiInstance.setScaling(gui::GUI::ScalingMode::Scaled);
     TestScaledControl protoRow(guiInstance, engine);
@@ -2581,7 +2585,8 @@ TEST(GUIListScale, should_change_row_density_without_changing_the_list_viewport)
     graphics::GraphicsOptions options;
     options.guiListScale = 0.5f;
     options.guiTextScale = 0.75f;
-    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource);
+    gui::PulsingAlpha pulsingAlpha;
+    gui::GUI guiInstance(options, engine.services().scene.graphs, engine.services().graphics, engine.services().resource, pulsingAlpha);
 
     resource::generated::GUI_CONTROLS definition;
     definition.CONTROLTYPE = static_cast<int>(gui::ControlType::ListBox);

From 5f87f51a77981bdd28dc96369250c3d8b4c47c74 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:29:38 -0400
Subject: [PATCH 04/23] - #1 reply conditions after the entry's scripts (both
 panels, both   titles): PARTLY FIXED. Conversation::loadEntry lists the
 replies after   runScripts. Left: the game lists replies when the entry's
 delay ends,   and presents the entry before its scripts (recorded in the
 log). - #2 the computer panel's numbers: FIXED. Written when the message is  
 set and again when the replies are listed, after the entry's scripts. - #10
 comptypes.2da: FIXED. Looked up at each conversation start; a   missing or
 empty table leaves the frame and type unchanged. - #11 KotOR's backdrop:
 FIXED. comp<N> from the clamped computer type   (one BackgroundType::Computer
 with a number). - #12 no hum for a KotOR computer one-liner: FIXED. The panel
 starts   hidden; the hum starts when it shows.

---
 include/reone/game/game.h              |   2 +
 include/reone/game/gui/computer.h      |  14 +-
 include/reone/game/gui/conversation.h  |  52 +++-
 include/reone/game/gui/dialog.h        |  13 +-
 include/reone/game/object/placeable.h  |   4 +
 include/reone/game/presentationgui.h   |   8 +-
 include/reone/game/types.h             |   3 +-
 include/reone/resource/dialog.h        |  20 ++
 src/libs/game/game.cpp                 |  26 +-
 src/libs/game/gui/computer.cpp         |  44 ++-
 src/libs/game/gui/conversation.cpp     | 397 +++++++++++++++++--------
 src/libs/game/gui/dialog.cpp           |  49 ++-
 src/libs/game/object/placeable.cpp     |  10 +
 src/libs/game/presentationgui.cpp      |  12 +-
 src/libs/resource/provider/dialogs.cpp |  10 +
 test/game/computer.cpp                 |   7 +-
 test/game/conversation.cpp             |  21 +-
 test/game/object.cpp                   |  13 +-
 18 files changed, 515 insertions(+), 190 deletions(-)

diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 0b6294ae9..34a42bfb2 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -464,6 +464,8 @@ class Game : boost::noncopyable {
 
     void openMainMenu();
     void openInGame();
+    /** Covers the screen with \p color at opacity \p alpha, over what is drawn so far. */
+    void renderScreenFill(const glm::vec3 &color, float alpha);
 
     bool hasPlayableRuntimeSession() const { return _runtimeSessionPlayable; }
 
diff --git a/include/reone/game/gui/computer.h b/include/reone/game/gui/computer.h
index e8c86dabc..581b21cc6 100644
--- a/include/reone/game/gui/computer.h
+++ b/include/reone/game/gui/computer.h
@@ -48,22 +48,24 @@ class ComputerGUI : public Conversation {
     void onEntryEnded() override;
 
 private:
+    /** What the conversation shows: nothing yet, the panel, or a camera shot. */
     enum class Presentation {
+        Hidden,
         Normal,
         Camera
     };
 
     ComputerCamGUI _cameraGUI;
-    Presentation _presentation {Presentation::Normal};
+    Presentation _presentation {Presentation::Hidden};
     /** The terminal hum, looping while the panel is up. */
     std::shared_ptr<audio::AudioClip> _humClip;
     /** The playing hum; none while the panel is down or a camera shot shows. */
     std::shared_ptr<audio::AudioSource> _hum;
-    /** KotOR: the panel frame of each computer type, the rows of comptypes.2da. */
-    std::vector<std::string> _panelFrames;
+    /** KotOR: the computer type the panel was last framed for, which numbers the backdrop. */
+    int _computerType {0};
 
     void returnFromCamera();
-    /** Switches between the panel and a camera shot; the terminal hum plays only with the panel. */
+    /** Switches between the panel and a camera shot; the terminal hum starts when the panel shows. */
     void setPresentation(Presentation presentation);
     /** Starts the terminal hum from its beginning. */
     void playHum();
@@ -141,9 +143,7 @@ class ComputerGUI : public Conversation {
     void configureSkillLabels();
     /** KotOR draws the static bands faintly. */
     void configureBands();
-    /** KotOR reads the panel frame of each computer type. */
-    void loadPanelFrames();
-    /** KotOR frames the panel by the conversation's computer type. */
+    /** KotOR frames the panel by the conversation's computer type, read from comptypes.2da. */
     void applyPanelFrame();
     /** Writes the leader's Computer Use and Repair totals and the party's spike and repair-part counts. */
     void refreshSkills();
diff --git a/include/reone/game/gui/conversation.h b/include/reone/game/gui/conversation.h
index f931c6794..c59abed86 100644
--- a/include/reone/game/gui/conversation.h
+++ b/include/reone/game/gui/conversation.h
@@ -116,6 +116,8 @@ class Conversation : public GameGUI {
 
     // Complete the active entry's presentation using the same path as expiry.
     void endCurrentEntry();
+    /** Skips the current entry, when it can be skipped: its voice stops and it ends now. */
+    void skipCurrentEntry();
 
     /** One line per reply, in reply order; an empty line stands for a reply that is not listed. */
     virtual void setReplyLines(std::vector<std::string> lines) = 0;
@@ -129,14 +131,46 @@ class Conversation : public GameGUI {
     virtual void onEntryEnded();
     /** The player chose \p reply from the listed replies; called before the reply's scripts run. */
     virtual void onReplyPicked(const resource::Dialog::EntryReply &reply);
+    /** A reply was taken without a choice, as the entry ended; called before the reply's scripts run. */
+    virtual void onReplyTaken(const resource::Dialog::EntryReply &reply);
+    /** Whether a participant of the list waited for still shows a dialog animation. */
+    virtual bool isDialogAnimationPlaying() const;
+
+    /**
+     * The dialogue letterbox's fade: a colour over the whole screen, which an
+     * entry sets and the arrival of its replies clears. It runs only while
+     * the letterbox is drawn.
+     */
+    struct EntryFade {
+        glm::vec3 color {0.0f};
+        float alpha {0.0f};
+        float delay {0.0f};
+        float length {0.0f};
+        /** Seconds since the fade was set, counted from a tenth of a second; 0 without a fade. */
+        float clock {0.0f};
+        /** The fade goes from the colour to clear, rather than from clear to the colour. */
+        bool fromColor {false};
+    };
+
+    const EntryFade &entryFade() const { return _entryFade; }
+    /** Runs the letterbox fade on by \p dt seconds, as the letterbox is drawn. */
+    void advanceEntryFade(float dt);
+    /** Clears the letterbox fade. */
+    void resetEntryFade();
 
 private:
     std::shared_ptr<audio::AudioSource> _currentVoice;
     Timer _endEntryTimer;
-    float _entryDuration {0.0f};
+    /** What the current entry, or the reply taken without a choice, waits for past its delay. */
+    int _waitFlags {0};
+    /** The entry that follows a reply taken without a choice, once the reply's delay and waits are over. */
+    std::optional<int> _pendingEntry;
+    /** The current entry was skipped: it ends without waiting. */
+    bool _entrySkipped {false};
+    EntryFade _entryFade;
     std::vector<const resource::Dialog::EntryReply *> _replies;
     bool _autoPickFirstReply {false};
-    /** Whether the conversation has shown the entry it ends on. */
+    /** Whether the conversation has listed the replies of the entry it ends on. */
     bool _endReached {false};
     AutoSkip *_autoSkip {nullptr};
     GlobalFade::DialogTicket _fadeDialog;
@@ -182,15 +216,25 @@ class Conversation : public GameGUI {
 
     bool isCurrent(uint64_t generation) const;
 
-    void loadConversationBackground();
     void loadCameraModel();
     void loadStartEntry();
     void loadVoiceOver();
     void scheduleEndOfEntry();
+    /** Holds the next entry back after \p reply, taken without a choice. */
+    void scheduleTakenReply(const resource::Dialog::EntryReply &reply);
+    /** Whether something the current entry or the taken reply waits for still goes on. */
+    bool isWaiting() const;
+    /** Stops the conversation's voice. */
+    void stopVoice();
+    /** Sets the letterbox fade of \p entry, if it has one. */
+    void startEntryFade(const resource::Dialog::EntryReply &entry);
+    /** Whether the letterbox fade is over, or none is set. */
+    bool isEntryFadeDone() const;
+    /** Whether the conversation's animated camera still plays its clip. */
+    bool isCameraAnimationPlaying() const;
     void loadReplies();
 
     bool isSkippableEntry() const;
-    bool isNonPresentationalEntry() const;
     /** Add the shown entry's \p text to the dialogue log under its speaker's name. */
     void logEntryLine(const std::string &text);
 
diff --git a/include/reone/game/gui/dialog.h b/include/reone/game/gui/dialog.h
index 6949a8393..0305c2592 100644
--- a/include/reone/game/gui/dialog.h
+++ b/include/reone/game/gui/dialog.h
@@ -42,6 +42,8 @@ class DialogGUI : public Conversation {
     }
 
     void update(float dt) override;
+    /** Draws the letterbox fade under the conversation's panel. */
+    void render() override;
 
     /** Selects, but does not activate, a reply for a scripted visual capture. */
     void selectReplyForCapture(int index);
@@ -96,6 +98,8 @@ class DialogGUI : public Conversation {
 
     /** The previous list's animation per participant, so unchanged ones are left alone. */
     std::map<std::string, int> _previousAnimations;
+    /** The participants whose dialog animations the current node waits for, in list order. */
+    std::vector<std::string> _waitedParticipants;
     /** The animations of the list before the previous one, whose participants the end of the conversation releases. */
     std::map<std::string, int> _lastButOneAnimations;
     /** The pull-back of the face shots in a row, while one is set. */
@@ -181,7 +185,11 @@ class DialogGUI : public Conversation {
     void applyDialogAnimation(const std::string &participant, int ordinal);
     /** Mixed-stunt participants that \p node does not drive from their stunt model leave their staging. */
     void restoreInactiveStuntParticipants(const resource::Dialog::EntryReply &node);
-    bool enterMixedStunt(Participant &participant, const std::shared_ptr<graphics::Animation> &animation, bool looping);
+    /**
+     * Stages a mixed-stunt participant in \p animation, a loop or a one-shot,
+     * shown as animation \p animationId.
+     */
+    bool enterMixedStunt(Participant &participant, const std::shared_ptr<graphics::Animation> &animation, bool looping, int animationId);
     void leaveMixedStunt(Participant &participant);
 
     static std::optional<CutAnimation> decodeCutAnimation(int ordinal);
@@ -208,6 +216,9 @@ class DialogGUI : public Conversation {
     void onLoadEntry() override;
     void onEntryEnded() override;
     void onReplyPicked(const resource::Dialog::EntryReply &reply) override;
+    void onReplyTaken(const resource::Dialog::EntryReply &reply) override;
+    /** A creature named by the last list of animations still shows a dialog animation. */
+    bool isDialogAnimationPlaying() const override;
 
     // Loading
 
diff --git a/include/reone/game/object/placeable.h b/include/reone/game/object/placeable.h
index 21249d405..4cb471b66 100644
--- a/include/reone/game/object/placeable.h
+++ b/include/reone/game/object/placeable.h
@@ -94,6 +94,8 @@ class Placeable : public Object {
      * pose. A world-space cut clip plays with the model at the world origin.
      */
     void playDialogAnimation(int id, bool looping);
+    /** The animation ID the placeable shows: a dialog one-shot while it plays, else its loop's; -1 for none. */
+    int currentAnimationId() const;
     /**
      * The placeable takes animation \p animation as its state. When the model
      * has the state's loop and does not show it already, the swing from the
@@ -340,6 +342,8 @@ class Placeable : public Object {
     std::string _openStateLoop;
     /** The animation whose loop the model shows; -1 while it shows none of its own. */
     int _shownAnimation {-1};
+    /** The dialog one-shot last played, by ID and clip, until a loop replaces it. */
+    std::optional<std::pair<int, std::string>> _dialogOneShot;
     std::shared_ptr<scene::WalkmeshSceneNode> _walkmesh;
 
     // Scripts
diff --git a/include/reone/game/presentationgui.h b/include/reone/game/presentationgui.h
index 570e35a17..4af1c1d80 100644
--- a/include/reone/game/presentationgui.h
+++ b/include/reone/game/presentationgui.h
@@ -106,7 +106,13 @@ class PresentationGUI : public gui::IGUIEventListener, boost::noncopyable {
     virtual void preload(gui::IGUI &gui);
     virtual void onGUILoaded() {}
 
-    void loadBackground(BackgroundType type);
+    /**
+     * Shows the full-screen backdrop of \p type behind the GUI.
+     *
+     * @param computerType for a computer backdrop, the computer type that
+     *        numbers KotOR's backdrop
+     */
+    void loadBackground(BackgroundType type, int computerType = 0);
 
     /** Centers the root panel in its authored canvas and reapplies layout. */
     void centerRootInCanvas(int canvasWidth, int canvasHeight);
diff --git a/include/reone/game/types.h b/include/reone/game/types.h
index 304abf37a..43e31ee19 100644
--- a/include/reone/game/types.h
+++ b/include/reone/game/types.h
@@ -51,8 +51,7 @@ enum class BackgroundType {
     None,
     Menu,
     Load,
-    Computer0,
-    Computer1
+    Computer
 };
 
 enum class WeaponType {
diff --git a/include/reone/resource/dialog.h b/include/reone/resource/dialog.h
index b3e9edef5..1b6a28a94 100644
--- a/include/reone/resource/dialog.h
+++ b/include/reone/resource/dialog.h
@@ -28,6 +28,12 @@ namespace resource {
 struct Dialog {
     struct WaitFlags {
         static constexpr int waitAnimFinish = 1;
+        /** The node waits for its sound to finish. */
+        static constexpr int waitSoundFinish = 2;
+        /** The node waits for its participants' dialog animations to finish. */
+        static constexpr int waitParticipantAnimFinish = 4;
+        /** The node waits for its fade to finish. */
+        static constexpr int waitFadeFinish = 8;
     };
 
     struct Stunt {
@@ -77,8 +83,20 @@ struct Dialog {
         float plotXPPercentage {0.0f};
         ActionParams actionParams;
         ActionParams actionParams2;
+        /** Seconds the node stays, or -1 for none of its own. */
         int delay {0};
         int waitFlags {0};
+        /** The node's sound is a recorded voice, which times the node by the dialog's entry delay. */
+        bool soundExists {false};
+        /** TSL: the entry cannot be skipped, even in a skippable conversation. */
+        bool nodeUnskippable {false};
+        /** How the entry fades the screen: 0 not at all; 1 and 4 towards the colour, others away from it. */
+        int fadeType {0};
+        glm::vec3 fadeColor {0.0f};
+        /** Seconds before the fade starts. */
+        float fadeDelay {0.0f};
+        /** Seconds the fade takes; none for types 1 and 2, which cut. */
+        float fadeLength {0.0f};
         int cameraId {-1};
         int cameraAngle {0};
         int cameraAnimation {0};
@@ -104,6 +122,8 @@ struct Dialog {
     std::string abortScript;
     int entryIndex {-1};
     bool animatedCutscene {false};
+    /** Seconds a voiced node without a delay of its own stays, besides waiting for its voice. */
+    uint32_t entryDelay {0};
     /** Shots frame the participants' models where they stand, rather than their camera hooks. */
     bool oldHitCheck {false};
     std::vector<Stunt> stunts;
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index bec3e0af6..ebd243f67 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -4438,6 +4438,13 @@ void Game::renderGlobalFade() {
     if (alpha <= 0.0f) {
         return;
     }
+    // Compatibility approximation: color, then blackfill.
+    for (auto color : {_globalFade.color(), glm::vec3(0.0f)}) {
+        renderScreenFill(color, alpha);
+    }
+}
+
+void Game::renderScreenFill(const glm::vec3 &color, float alpha) {
     auto &graphics = _services.graphics;
     auto &context = graphics.context;
     GlobalUniforms previousGlobals;
@@ -4457,17 +4464,14 @@ void Game::renderGlobalFade() {
                     context.withPolygonMode(PolygonMode::Fill, [&]() {
                         // Inherit the GUI viewport, including window/drawable
                         // scaling. Logical GUI dimensions need not be pixels.
-                        // Compatibility approximation: color, then blackfill.
-                        for (auto color : {_globalFade.color(), glm::vec3(0.0f)}) {
-                            graphics.uniforms.setLocals([&](auto &locals) {
-                                locals.reset();
-                                locals.model = glm::scale(glm::mat4(1.0f),
-                                                          glm::vec3(_options.graphics.width, _options.graphics.height, 1.0f));
-                                locals.color = glm::vec4(color, alpha);
-                            });
-                            context.useProgram(graphics.shaderRegistry.get(ShaderProgramId::mvpColor));
-                            graphics.meshRegistry.get(MeshName::quad).draw(graphics.statistic);
-                        }
+                        graphics.uniforms.setLocals([&](auto &locals) {
+                            locals.reset();
+                            locals.model = glm::scale(glm::mat4(1.0f),
+                                                      glm::vec3(_options.graphics.width, _options.graphics.height, 1.0f));
+                            locals.color = glm::vec4(color, alpha);
+                        });
+                        context.useProgram(graphics.shaderRegistry.get(ShaderProgramId::mvpColor));
+                        graphics.meshRegistry.get(MeshName::quad).draw(graphics.statistic);
                     });
                 });
             });
diff --git a/src/libs/game/gui/computer.cpp b/src/libs/game/gui/computer.cpp
index 336f9ced2..e9d2fd563 100644
--- a/src/libs/game/gui/computer.cpp
+++ b/src/libs/game/gui/computer.cpp
@@ -24,7 +24,6 @@
 #include "reone/game/game.h"
 #include "reone/game/object/creature.h"
 #include "reone/game/party.h"
-#include "reone/game/twodautil.h"
 #include "reone/resource/2da.h"
 #include "reone/resource/di/services.h"
 #include "reone/resource/provider/2das.h"
@@ -50,9 +49,6 @@ static constexpr char kComputerTypesResRef[] = "comptypes";
 void ComputerGUI::init() {
     Conversation::init();
     _cameraGUI.init();
-    if (!isTSL()) {
-        loadPanelFrames();
-    }
 }
 
 bool ComputerGUI::handle(const input::Event &event) {
@@ -79,12 +75,12 @@ void ComputerGUI::render() {
 
 void ComputerGUI::onStart() {
     applyPanelFrame();
-    _presentation = Presentation::Normal;
-    playHum();
+    loadBackground(BackgroundType::Computer, _computerType);
+    _presentation = Presentation::Hidden;
 }
 
 void ComputerGUI::onFinish() {
-    _presentation = Presentation::Normal;
+    _presentation = Presentation::Hidden;
     stopHum();
 }
 
@@ -101,8 +97,9 @@ void ComputerGUI::onEntryEnded() {
 }
 
 void ComputerGUI::returnFromCamera() {
+    // Returning from a camera shot skips the entry.
     if (_presentation == Presentation::Camera) {
-        endCurrentEntry();
+        skipCurrentEntry();
     }
 }
 
@@ -113,7 +110,7 @@ void ComputerGUI::setPresentation(Presentation presentation) {
     _presentation = presentation;
     if (_presentation == Presentation::Camera) {
         stopHum();
-    } else {
+    } else if (_presentation == Presentation::Normal) {
         playHum();
     }
 }
@@ -181,22 +178,19 @@ void ComputerGUI::configureBands() {
     }
 }
 
-void ComputerGUI::loadPanelFrames() {
-    const auto types = getRequiredTwoDA(_services.resource.twoDas, kComputerTypesResRef);
-    _panelFrames.clear();
-    for (int row = 0; row < types->getRowCount(); ++row) {
-        _panelFrames.push_back(types->getString(row, "computerbackground"));
-    }
-}
-
 void ComputerGUI::applyPanelFrame() {
     if (isTSL()) {
         return;
     }
-    // A computer type without a row in comptypes.2da takes the first row's
-    // frame.
-    const auto type = static_cast<size_t>(_dialog->computerType);
-    _gui->rootControl().setBorderFill(_panelFrames.at(type < _panelFrames.size() ? type : 0));
+    // Without the table, or with no rows in it, the panel keeps its frame
+    // and its type. A computer type without a row takes the first row.
+    const auto types = _services.resource.twoDas.get(kComputerTypesResRef);
+    if (!types || types->getRowCount() == 0) {
+        return;
+    }
+    const int type = static_cast<int>(_dialog->computerType);
+    _computerType = type < types->getRowCount() ? type : 0;
+    _gui->rootControl().setBorderFill(types->getString(_computerType, "computerbackground"));
 }
 
 void ComputerGUI::refreshSkills() {
@@ -217,11 +211,15 @@ void ComputerGUI::refreshSkills() {
 }
 
 void ComputerGUI::setMessage(std::string message) {
+    refreshSkills();
+
     ListBox::Item item;
     item.text = std::move(message);
 
     _controls.LB_MESSAGE->clearItems();
     _controls.LB_MESSAGE->addItem(std::move(item));
+    // The replies of the entry are listed when it ends.
+    _controls.LB_REPLIES->clearItems();
 }
 
 void ComputerGUI::setReplyLines(std::vector<std::string> lines) {
@@ -236,8 +234,8 @@ void ComputerGUI::setReplyLines(std::vector<std::string> lines) {
         item.text = lines[i];
         _controls.LB_REPLIES->addItem(std::move(item));
     }
-    // The numbers are written once per entry, when its replies are listed,
-    // so they show what the entry's reply conditions leave.
+    // The numbers are written when an entry's message is set and again when
+    // its replies are listed, as the entry ends.
     refreshSkills();
 }
 
diff --git a/src/libs/game/gui/conversation.cpp b/src/libs/game/gui/conversation.cpp
index 7fa02d19e..f488a7b3a 100644
--- a/src/libs/game/gui/conversation.cpp
+++ b/src/libs/game/gui/conversation.cpp
@@ -17,6 +17,7 @@
 
 #include "reone/game/gui/conversation.h"
 
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <limits>
@@ -48,7 +49,10 @@ namespace reone {
 
 namespace game {
 
-static constexpr float kDefaultEntryDuration = 3.0f;
+// The time a line takes to speak: a second, and a little more for each
+// character, in whole seconds.
+static constexpr float kSpokenTimeBase = 1.0f;
+static constexpr float kSpokenTimePerCharacter = 0.11f;
 
 // Camera shots: the placed camera and same-pair angles, the animated shot
 // range, and the video effect values a shot can carry besides a row.
@@ -110,12 +114,15 @@ void Conversation::start(const std::shared_ptr<Dialog> &dialog, const std::share
     auto generation = ++_generation;
     _fadeDialog = std::move(admission);
     if (_dialog) {
+        stopVoice();
+        resetEntryFade();
         onFinish();
         if (!isCurrent(generation)) {
             return;
         }
         releaseDialogParticipants(_owner.resolve());
     }
+    _pendingEntry.reset();
     debug("Start " + dialog->resRef, LogChannel::Conversation);
 
     _paused = false;
@@ -132,7 +139,6 @@ void Conversation::start(const std::shared_ptr<Dialog> &dialog, const std::share
         attachDialogParticipant(listener);
     }
 
-    loadConversationBackground();
     loadCameraModel();
     onStart();
     if (isCurrent(generation)) {
@@ -200,23 +206,6 @@ void Conversation::runAreaEndDialogScripts(const Object &dialogOwner) {
     }
 }
 
-static BackgroundType getBackgroundType(ComputerType compType) {
-    switch (compType) {
-    case ComputerType::Rakatan:
-        return BackgroundType::Computer1;
-    default:
-        return BackgroundType::Computer0;
-    }
-}
-
-void Conversation::loadConversationBackground() {
-    if (_dialog->conversationType == ConversationType::Computer) {
-        loadBackground(getBackgroundType(_dialog->computerType));
-    } else {
-        loadBackground(BackgroundType::None);
-    }
-}
-
 void Conversation::loadCameraModel() {
     std::string modelResRef(_dialog->cameraModel);
     _cameraModel = modelResRef.empty() ? nullptr : _services.resource.models.get(modelResRef);
@@ -336,6 +325,9 @@ void Conversation::finish(bool runsEndScript, bool aborted) {
     _game.setDialogUnderWay(false);
     _paused = false;
     _entryEnded = true;
+    _pendingEntry.reset();
+    stopVoice();
+    resetEntryFade();
     onFinish();
     if (_generation != generation) {
         return;
@@ -388,10 +380,9 @@ void Conversation::cleanupForModuleTransition() {
     if (!_dialog) {
         return;
     }
-    if (_currentVoice) {
-        _currentVoice->stop();
-        _currentVoice.reset();
-    }
+    _pendingEntry.reset();
+    stopVoice();
+    resetEntryFade();
     _lipAnimation.reset();
     onFinish();
     if (_generation == generation) {
@@ -431,71 +422,32 @@ void Conversation::loadEntry(int index, bool start) {
         oneLiner = links.empty() || (links.size() == 1ll && _dialog->getReply(links.front().index).entries.empty());
     }
 
-    if (!oneLiner) {
-        applyStatusSummaryEntries(*_currentEntry);
-    }
+    // An entry's replies are listed when it ends.
+    _replies.clear();
+    _autoPickFirstReply = false;
 
     std::string entryText(_game.substituteCustomTokens(_currentEntry->text));
-    setMessage(entryText);
-    if (oneLiner) {
-        _replies.clear();
-        _endReached = true;
-    } else {
-        loadReplies();
-        if (!isCurrent(generation)) {
-            return;
-        }
-    }
-    loadVoiceOver();
-
-    // Entry publication consumes only the current handoff. An entry action
-    // below can immediately replace this automatic reveal with its own fade.
-    _game.globalFade().revealDialog(_fadeDialog);
-
-    // Run entry scripts; a one-liner runs them after its bark. An entry action
-    // can start another conversation, which replaces this one outright.
-    // Holding the dialogue keeps this entry and its replies alive for the
-    // script to act on, and tells us to stop rather than carry on driving the
-    // new session with the old one's state.
-    if (!oneLiner) {
-        runScripts(*_currentEntry);
-        if (!isCurrent(generation)) {
-            return;
-        }
-    }
-
-    if (!oneLiner && isNonPresentationalEntry()) {
-        pickReply(0);
-        return;
-    }
-    if (!oneLiner) {
-        logEntryLine(entryText);
-    }
-
-    scheduleEndOfEntry();
-    if (isAnimatedCameraShot()) {
-        _animatedView = true;
-    } else {
-        takeCameraShot(*_currentEntry, _entryCameraAngle);
-    }
-    onLoadEntry();
-    if (!isCurrent(generation)) {
-        return;
-    }
-
     if (oneLiner) {
         debug("Dialog: finish (one-liner)");
 
-        // A line with text is barked, and the conversation's end script runs
-        // then, with the owner's own end-dialogue script but no other's; a
-        // line without text shows nothing and runs no end script. The
-        // entry's actions follow, then the sole reply's, whether or not its
-        // condition holds, all with the owner as the caller. An action can
-        // start another conversation, which then stands. Ending the entry
-        // first stops the update timer from ending it again.
+        // A one-liner is not shown in the conversation's panel. A line with
+        // text is barked, and the conversation's end script runs then, with
+        // the owner's own end-dialogue script but no other's; a line without
+        // text shows nothing and runs no end script. The entry's actions
+        // follow, then the sole reply's, whether or not its condition holds,
+        // all with the owner as the caller. An action can start another
+        // conversation, which then stands. Ending the entry first stops the
+        // update timer from ending it again.
+        _endReached = true;
+        // The bark keeps its voice: the conversation ending does not stop it.
+        loadVoiceOver();
+        _currentVoice.reset();
+        _game.globalFade().revealDialog(_fadeDialog);
         _entryEnded = true;
         if (!_currentEntry->text.empty()) {
-            setBarkText(std::move(entryText), _entryDuration);
+            // The bark shows for the time its line takes to speak.
+            const float barkDuration = kSpokenTimeBase + kSpokenTimePerCharacter * static_cast<float>(entryText.size());
+            setBarkText(std::move(entryText), barkDuration);
             if (auto owner = _owner.resolve()) {
                 runEndScript(*_dialog, *owner);
                 if (!isCurrent(generation)) {
@@ -521,12 +473,46 @@ void Conversation::loadEntry(int index, bool start) {
         return;
     }
 
+    // The entry is shown before its scripts run: its message, its line in the
+    // dialogue list, its voice, its camera shot and its participants. Its
+    // journal entry and plot experience follow.
+    setMessage(entryText);
+    logEntryLine(entryText);
+    loadVoiceOver();
+    scheduleEndOfEntry();
+    if (isAnimatedCameraShot()) {
+        _animatedView = true;
+    } else {
+        takeCameraShot(*_currentEntry, _entryCameraAngle);
+    }
+    onLoadEntry();
+    if (!isCurrent(generation)) {
+        return;
+    }
     applyShotVideoEffect();
+    resetEntryFade();
+    startEntryFade(*_currentEntry);
+    applyStatusSummaryEntries(*_currentEntry);
+
+    // Entry publication consumes only the current handoff. An entry action
+    // below can immediately replace this automatic reveal with its own fade.
+    _game.globalFade().revealDialog(_fadeDialog);
+
+    // Run entry scripts. An entry action can start another conversation, which
+    // replaces this one outright. Holding the dialogue keeps this entry alive
+    // for the script to act on, and tells us to stop rather than carry on
+    // driving the new session with the old one's state. The replies are
+    // listed when the entry ends, so their conditions see what its scripts
+    // did.
+    runScripts(*_currentEntry);
+    if (!isCurrent(generation)) {
+        return;
+    }
 
     if (_autoSkip) {
         if (std::optional<bool> skip = _autoSkip->trySkipEntry()) {
             if (skip.value() && !_paused) {
-                endCurrentEntry();
+                skipCurrentEntry();
             }
         }
     }
@@ -648,13 +634,14 @@ std::optional<std::reference_wrapper<const Dialog::EntryReply>> Conversation::fi
     return std::cref(*_replies.front());
 }
 
+// An entry with a sound stops the voice before it; one without leaves it
+// playing.
 void Conversation::loadVoiceOver() {
-    // Stop previous voice, if any
-    if (_currentVoice) {
-        _currentVoice->stop();
-        _currentVoice.reset();
-        _lipAnimation.reset();
+    _lipAnimation.reset();
+    if (_currentEntry->sound.empty() && _currentEntry->voResRef.empty()) {
+        return;
     }
+    stopVoice();
 
     // Play current voice over either from Sound or from VO_ResRef
     std::string voiceResRef;
@@ -678,24 +665,163 @@ void Conversation::loadVoiceOver() {
     }
 }
 
-void Conversation::scheduleEndOfEntry() {
-    float duration = kDefaultEntryDuration;
+// The time a node's text takes to speak, in whole seconds; an empty line takes
+// none. TSL measures the text with its tokens resolved and its leading and
+// trailing spaces trimmed.
+static float getSpokenTime(const std::string &text, const Game &game) {
+    std::string spoken(text);
+    if (game.isTSL()) {
+        spoken = game.substituteCustomTokens(spoken);
+        spoken.erase(0, spoken.find_first_not_of(' '));
+        spoken.erase(spoken.find_last_not_of(' ') + 1);
+    }
+    if (spoken.empty()) {
+        return 0.0f;
+    }
+    return std::trunc(kSpokenTimeBase + kSpokenTimePerCharacter * static_cast<float>(spoken.size()));
+}
+
+static bool hasSound(const Dialog::EntryReply &node) {
+    return !node.sound.empty() || !node.voResRef.empty();
+}
+
+// A node with a sound and no delay or wait flags of its own waits for its
+// sound.
+static int getWaitFlags(const Dialog::EntryReply &node) {
+    if (node.delay == -1 && hasSound(node) && node.waitFlags == 0) {
+        return Dialog::WaitFlags::waitSoundFinish;
+    }
+    return node.waitFlags;
+}
+
+// A node's own delay, or, for one with a sound and no delay of its own, the
+// dialog's entry delay.
+static float getAuthoredDelay(const Dialog::EntryReply &node, const Dialog &dialog) {
+    return node.delay != -1 ? static_cast<float>(node.delay) : static_cast<float>(dialog.entryDelay);
+}
 
-    if (_cameraModel && (_currentEntry->waitFlags & Dialog::WaitFlags::waitAnimFinish)) {
-        std::string animName(AnimatedCamera::getShotClipName(_currentEntry->cameraAnimation));
-        std::shared_ptr<Animation> animation(_cameraModel->getAnimation(animName));
-        if (animation) {
-            duration = animation->length();
+// An entry stays for its delay: its own; else, with a sound, the dialog's
+// entry delay when the sound is a recorded voice; else none when it waits for
+// something; else none in an animated cutscene, and otherwise the time its
+// text takes to speak. Past its delay, it stays while what it waits for goes
+// on: its camera animation, its sound and its participants' dialog
+// animations.
+void Conversation::scheduleEndOfEntry() {
+    const Dialog::EntryReply &entry = *_currentEntry;
+    const int waitFlags = getWaitFlags(entry);
+    float duration = 0.0f;
+    if (entry.delay != -1 || (hasSound(entry) && entry.soundExists)) {
+        duration = getAuthoredDelay(entry, *_dialog);
+    } else if (!_dialog->isAnimatedCutscene() && (hasSound(entry) || waitFlags == 0)) {
+        duration = getSpokenTime(entry.text, _game);
+    }
+
+    if (_cameraModel && (waitFlags & Dialog::WaitFlags::waitAnimFinish)) {
+        std::string animName(AnimatedCamera::getShotClipName(entry.cameraAnimation));
+        if (std::shared_ptr<Animation> animation = _cameraModel->getAnimation(animName)) {
+            duration = std::max(duration, animation->length());
         }
-    } else if (_currentEntry->delay != -1) {
-        duration = static_cast<float>(_currentEntry->delay);
-    } else if (_currentVoice) {
-        duration = _currentVoice->duration();
     }
 
     _entryEnded = false;
-    _entryDuration = duration;
+    _entrySkipped = false;
+    _endEntryTimer.reset(duration);
+    _waitFlags = waitFlags;
+}
+
+// A reply taken without a choice holds the next entry back: for its delay
+// when it waits for its sound; else not at all when it waits for something
+// else or in an animated cutscene; else for the time its text takes to speak.
+// Past that, the next entry waits for what the reply waits for, except in an
+// animated cutscene.
+void Conversation::scheduleTakenReply(const Dialog::EntryReply &reply) {
+    const int waitFlags = getWaitFlags(reply);
+    float duration = 0.0f;
+    if (waitFlags & Dialog::WaitFlags::waitSoundFinish) {
+        duration = getAuthoredDelay(reply, *_dialog);
+    } else if (!_dialog->isAnimatedCutscene() && (reply.delay != -1 || hasSound(reply) || waitFlags == 0)) {
+        duration = getSpokenTime(reply.text, _game);
+    }
     _endEntryTimer.reset(duration);
+    _waitFlags = _dialog->isAnimatedCutscene() ? 0 : waitFlags;
+}
+
+bool Conversation::isWaiting() const {
+    if ((_waitFlags & Dialog::WaitFlags::waitSoundFinish) && _currentVoice && _currentVoice->isPlaying()) {
+        return true;
+    }
+    if ((_waitFlags & Dialog::WaitFlags::waitFadeFinish) && !isEntryFadeDone()) {
+        return true;
+    }
+    if ((_waitFlags & Dialog::WaitFlags::waitAnimFinish) && isCameraAnimationPlaying()) {
+        return true;
+    }
+    return (_waitFlags & Dialog::WaitFlags::waitParticipantAnimFinish) && isDialogAnimationPlaying();
+}
+
+// Fade types 1 and 4 go towards the colour; the others come away from it.
+void Conversation::startEntryFade(const Dialog::EntryReply &entry) {
+    static constexpr int kCutToColorFade = 1;
+    static constexpr int kFadeToColor = 4;
+    static constexpr float kFadeClockStart = 0.1f;
+    if (entry.fadeType == 0) {
+        return;
+    }
+    _entryFade.fromColor = entry.fadeType != kCutToColorFade && entry.fadeType != kFadeToColor;
+    _entryFade.color = entry.fadeColor;
+    _entryFade.alpha = _entryFade.fromColor ? 1.0f : 0.0f;
+    _entryFade.delay = entry.fadeDelay;
+    _entryFade.length = entry.fadeLength;
+    _entryFade.clock = kFadeClockStart;
+}
+
+// The clock skips a frame of five seconds or more. Past its delay the fade
+// moves by the share of its length gone by.
+void Conversation::advanceEntryFade(float dt) {
+    static constexpr float kLongestFadeFrame = 5.0f;
+    if (_entryFade.clock <= 0.0f) {
+        return;
+    }
+    if (dt < kLongestFadeFrame) {
+        _entryFade.clock += dt;
+    }
+    if (_entryFade.clock <= _entryFade.delay) {
+        return;
+    }
+    const float progress = (_entryFade.clock - _entryFade.delay) / _entryFade.length;
+    const float alpha = _entryFade.fromColor ? std::max(0.0f, 1.0f - progress) : std::min(1.0f, progress);
+    _entryFade.alpha = std::clamp(alpha, 0.0f, 1.0f);
+}
+
+void Conversation::resetEntryFade() {
+    _entryFade = EntryFade();
+}
+
+bool Conversation::isEntryFadeDone() const {
+    return _entryFade.clock == 0.0f || _entryFade.clock > _entryFade.delay + _entryFade.length;
+}
+
+bool Conversation::isDialogAnimationPlaying() const {
+    return false;
+}
+
+void Conversation::onReplyTaken(const Dialog::EntryReply &) {
+}
+
+// The camera plays a clip only in a conversation with a camera model.
+bool Conversation::isCameraAnimationPlaying() const {
+    if (!_cameraModel) {
+        return false;
+    }
+    auto camera = _game.module()->area()->getCamera<AnimatedCamera>(CameraType::Animated);
+    return !camera->isAnimationFinished();
+}
+
+void Conversation::stopVoice() {
+    if (_currentVoice) {
+        _currentVoice->stop();
+        _currentVoice.reset();
+    }
 }
 
 // A reply as listed and logged: its tokens resolved and, in TSL, its leading
@@ -790,6 +916,10 @@ void Conversation::refreshReplies() {
 }
 
 void Conversation::pickReply(int index) {
+    // Once a reply is taken, the next entry is on its way.
+    if (_pendingEntry) {
+        return;
+    }
     auto generation = _generation;
     debug("Pick reply " + std::to_string(index), LogChannel::Conversation);
     const Dialog::EntryReply &reply = *_replies[index];
@@ -806,7 +936,15 @@ void Conversation::pickReply(int index) {
         }
     }
 
+    // A reply taken without a choice sets its letterbox fade and its own
+    // delay and waits. A chosen reply keeps the entry's waits.
     applyStatusSummaryEntries(reply);
+    const bool taken = _autoPickFirstReply;
+    if (taken) {
+        startEntryFade(reply);
+        onReplyTaken(reply);
+        scheduleTakenReply(reply);
+    }
 
     // Run reply scripts
     auto dialog = _dialog;
@@ -827,6 +965,10 @@ void Conversation::pickReply(int index) {
         finish();
         return;
     }
+    if (!_endEntryTimer.elapsed() || isWaiting()) {
+        _pendingEntry = entryIdx;
+        return;
+    }
     loadEntry(entryIdx);
 }
 
@@ -848,20 +990,32 @@ bool Conversation::handle(const input::Event &event) {
 }
 
 bool Conversation::handleMouseButtonDown(const input::MouseButtonEvent &event) {
+    // Skipping an entry ends its delay and stops its voice.
     if (event.button == input::MouseButton::Left && !_entryEnded && isSkippableEntry()) {
         _endEntryTimer.reset(0);
+        _entrySkipped = true;
+        stopVoice();
         return true;
     }
     return false;
 }
 
+// A skip takes effect only in a skippable conversation and, in TSL, on an
+// entry not marked unskippable.
 bool Conversation::isSkippableEntry() const {
-    return g_allEntriesSkippable || (_dialog->isSkippable() && !_paused);
+    if (g_allEntriesSkippable) {
+        return true;
+    }
+    const bool nodeUnskippable = _game.isTSL() && _currentEntry && _currentEntry->nodeUnskippable;
+    return _dialog->isSkippable() && !nodeUnskippable && !_paused;
 }
 
 // An entry shown in the conversation goes to the dialog list under its
 // speaker's name: the object its speaker tag names, or else the owner.
 void Conversation::logEntryLine(const std::string &text) {
+    if (text.empty()) {
+        return;
+    }
     auto owner = _owner.resolve();
     std::shared_ptr<Object> speaker;
     if (!_currentEntry->speaker.empty() && owner && owner->spatialArea()) {
@@ -875,30 +1029,22 @@ void Conversation::logEntryLine(const std::string &text) {
     }
 }
 
-bool Conversation::isNonPresentationalEntry() const {
-    return _autoPickFirstReply &&
-           _currentEntry->text.empty() &&
-           _currentEntry->sound.empty() &&
-           _currentEntry->voResRef.empty() &&
-           _currentEntry->cameraAnimation == 0 &&
-           _currentEntry->cameraId == 0 &&
-           _currentEntry->cameraAngle == 0 &&
-           _currentEntry->animations.empty() &&
-           _currentEntry->delay == -1;
-}
-
 void Conversation::endCurrentEntry() {
     if (!_currentEntry || _entryEnded || _paused) {
         return;
     }
     auto generation = _generation;
     _entryEnded = true;
+    // An entry ends once its time is up.
+    _endEntryTimer.reset(0);
 
-    // Stop voice over, if any
-    if (_currentVoice) {
-        _currentVoice->stop();
-        _currentVoice.reset();
+    // The entry's replies arrive as it ends: their conditions are tested and
+    // they are listed now, and the letterbox fade clears.
+    loadReplies();
+    if (!isCurrent(generation)) {
+        return;
     }
+    resetEntryFade();
 
     onEntryEnded();
     if (!isCurrent(generation)) {
@@ -917,6 +1063,14 @@ void Conversation::endCurrentEntry() {
     }
 }
 
+void Conversation::skipCurrentEntry() {
+    if (!_currentEntry || _entryEnded || _paused || !isSkippableEntry()) {
+        return;
+    }
+    stopVoice();
+    endCurrentEntry();
+}
+
 void Conversation::onEntryEnded() {
 }
 
@@ -924,7 +1078,7 @@ void Conversation::onReplyPicked(const Dialog::EntryReply &) {
 }
 
 bool Conversation::handleKeyUp(const input::KeyEvent &event) {
-    if (!_entryEnded) {
+    if (!_entryEnded || _pendingEntry) {
         return false;
     }
 
@@ -954,9 +1108,16 @@ void Conversation::update(float dt) {
     GameGUI::update(dt);
     if (!_entryEnded) {
         _endEntryTimer.update(dt);
-        if (!_paused && (_endEntryTimer.elapsed() || (_currentVoice && !_currentVoice->isPlaying()))) {
+        if (!_paused && _endEntryTimer.elapsed() && (_entrySkipped || !isWaiting())) {
             endCurrentEntry();
         }
+    } else if (_pendingEntry) {
+        _endEntryTimer.update(dt);
+        if (!_paused && _endEntryTimer.elapsed() && !isWaiting()) {
+            const int index = *_pendingEntry;
+            _pendingEntry.reset();
+            loadEntry(index);
+        }
     }
 }
 
diff --git a/src/libs/game/gui/dialog.cpp b/src/libs/game/gui/dialog.cpp
index 9a118b084..4120a4c8d 100644
--- a/src/libs/game/gui/dialog.cpp
+++ b/src/libs/game/gui/dialog.cpp
@@ -211,11 +211,22 @@ void DialogGUI::configureReplies() {
     _controls.LB_REPLIES->protoItem().setTextColor(_baseColor);
 }
 
+void DialogGUI::render() {
+    const EntryFade &fade = entryFade();
+    if (fade.alpha > 0.0f) {
+        _game.renderScreenFill(fade.color, fade.alpha);
+    }
+    Conversation::render();
+}
+
 void DialogGUI::onStart() {
+    // The letterbox shows with the conversation, without a fade.
+    resetEntryFade();
     _currentSpeaker = owner();
     endSpeakerPair();
     _previousAnimations.clear();
     _lastButOneAnimations.clear();
+    _waitedParticipants.clear();
     loadStuntParticipants();
 
     _dialogCameraStale = true;
@@ -324,7 +335,7 @@ void DialogGUI::restoreInactiveStuntParticipants(const Dialog::EntryReply &node)
     }
 }
 
-bool DialogGUI::enterMixedStunt(Participant &participant, const std::shared_ptr<Animation> &animation, bool looping) {
+bool DialogGUI::enterMixedStunt(Participant &participant, const std::shared_ptr<Animation> &animation, bool looping, int animationId) {
     auto creature = participant.creature.resolve();
     if (!creature) {
         participant.mixedStuntActive = false;
@@ -338,7 +349,7 @@ bool DialogGUI::enterMixedStunt(Participant &participant, const std::shared_ptr<
     AnimationProperties properties;
     properties.flags = AnimationFlags::propagate | (looping ? AnimationFlags::loop : 0);
     properties.scale = 1.0f;
-    if (!creature->playExternalAnimation(animation, std::move(properties))) {
+    if (!creature->playExternalAnimation(animation, std::move(properties), AnimationSource {animationId, true})) {
         return false;
     }
 
@@ -659,7 +670,9 @@ void DialogGUI::updateParticipantAnimations(const Dialog::EntryReply &node) {
     // listener and the speaker take their poses unless the list names them.
     std::map<std::string, int> animations;
     std::vector<std::shared_ptr<Object>> listed;
+    _waitedParticipants.clear();
     for (auto &anim : node.animations) {
+        _waitedParticipants.push_back(anim.participant);
         animations[anim.participant] = anim.animation;
         if (auto object = participantObject(anim.participant)) {
             listed.push_back(std::move(object));
@@ -838,7 +851,7 @@ bool DialogGUI::applyCutAnimation(const std::string &participant, const CutAnima
         const std::string name = stuntCreature ? getCutClipName(cut.name, *stuntCreature) : cut.name;
         if (auto animation = stunt.model->getAnimation(name)) {
             if (!_dialog->isAnimatedCutscene()) {
-                return enterMixedStunt(stunt, animation, cut.looping);
+                return enterMixedStunt(stunt, animation, cut.looping, cut.id);
             }
             // The clip's ID decides whether it plays at the world origin.
             AnimationProperties properties;
@@ -982,6 +995,7 @@ void DialogGUI::onFinish() {
     }
     _previousAnimations.clear();
     _lastButOneAnimations.clear();
+    _waitedParticipants.clear();
 
     if (hasStuntPresentation()) {
         releaseStuntParticipants();
@@ -1022,6 +1036,8 @@ void DialogGUI::onEntryEnded() {
 
 // A chosen reply animates its participants and poses the answering pair,
 // except in an animated cutscene.
+// In an animated cutscene a chosen reply leaves the entry's participants
+// animated and waited for.
 void DialogGUI::onReplyPicked(const Dialog::EntryReply &reply) {
     if (_dialog->isAnimatedCutscene()) {
         return;
@@ -1030,6 +1046,31 @@ void DialogGUI::onReplyPicked(const Dialog::EntryReply &reply) {
     updateParticipantAnimations(reply);
 }
 
+// A reply taken without a choice puts its participants in the first places of
+// the list waited for, as far as the list goes.
+void DialogGUI::onReplyTaken(const Dialog::EntryReply &reply) {
+    const size_t count = std::min(reply.animations.size(), _waitedParticipants.size());
+    for (size_t i = 0; i < count; ++i) {
+        _waitedParticipants[i] = reply.animations[i].participant;
+    }
+}
+
+bool DialogGUI::isDialogAnimationPlaying() const {
+    for (const auto &participant : _waitedParticipants) {
+        auto object = participantObject(participant);
+        int animationId = -1;
+        if (auto creature = std::dynamic_pointer_cast<Creature>(object)) {
+            animationId = creature->currentAnimationId();
+        } else if (auto placeable = std::dynamic_pointer_cast<Placeable>(object)) {
+            animationId = placeable->currentAnimationId();
+        }
+        if (_services.game.animations.isDialogAnimation(animationId)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 void DialogGUI::setMessage(std::string message) {
     _controls.LBL_MESSAGE->setTextMessage(message);
 }
@@ -1073,7 +1114,9 @@ void DialogGUI::setReplyLines(std::vector<std::string> lines) {
     _controls.LB_REPLIES->protoItem().setExtent(std::move(extent));
 }
 
+// The letterbox is drawn with the conversation, so its fade runs with it.
 void DialogGUI::update(float dt) {
+    advanceEntryFade(dt);
     Conversation::update(dt);
 
     // The dialog camera follows the pair of its shot.
diff --git a/src/libs/game/object/placeable.cpp b/src/libs/game/object/placeable.cpp
index 13163d304..dde679b23 100644
--- a/src/libs/game/object/placeable.cpp
+++ b/src/libs/game/object/placeable.cpp
@@ -767,6 +767,7 @@ bool Placeable::showAnimationLoop(int id) {
     setPlacedAtOrigin(isWorldSpaceCutClip(id));
     _openStateLoop.clear();
     _shownAnimation = id;
+    _dialogOneShot.reset();
     model->playAnimation(clip, nullptr, AnimationProperties::fromFlags(AnimationFlags::loop));
     return true;
 }
@@ -789,6 +790,15 @@ void Placeable::playDialogAnimation(int id, bool looping) {
     setPlacedAtOrigin(isWorldSpaceCutClip(id));
     model->playAnimation(clip);
     _openStateLoop = getPlaceableClip(_services.game.animations, kDefaultAnimationId);
+    _dialogOneShot = std::make_pair(id, clip);
+}
+
+int Placeable::currentAnimationId() const {
+    auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
+    if (_dialogOneShot && model && model->activeAnimationName() == _dialogOneShot->second && !model->isAnimationFinished()) {
+        return _dialogOneShot->first;
+    }
+    return _shownAnimation;
 }
 
 void Placeable::showStateAnimation() {
diff --git a/src/libs/game/presentationgui.cpp b/src/libs/game/presentationgui.cpp
index c8865a612..76c989320 100644
--- a/src/libs/game/presentationgui.cpp
+++ b/src/libs/game/presentationgui.cpp
@@ -106,7 +106,7 @@ void PresentationGUI::render() {
     }
 }
 
-void PresentationGUI::loadBackground(BackgroundType type) {
+void PresentationGUI::loadBackground(BackgroundType type, int computerType) {
     std::string resRef;
 
     if (isTSL()) {
@@ -118,8 +118,7 @@ void PresentationGUI::loadBackground(BackgroundType type) {
             // world cannot show through at wider aspect ratios.
             resRef = "blackfill";
             break;
-        case BackgroundType::Computer0:
-        case BackgroundType::Computer1:
+        case BackgroundType::Computer:
             // The terminal bezel is the computer_p panel's own fill; using it
             // as the backdrop too drew a cropped second copy behind the
             // panel. The game's terminal sits on a void fill.
@@ -146,11 +145,8 @@ void PresentationGUI::loadBackground(BackgroundType type) {
         case BackgroundType::Load:
             resRef += "load";
             break;
-        case BackgroundType::Computer0:
-            resRef += "comp0";
-            break;
-        case BackgroundType::Computer1:
-            resRef += "comp1";
+        case BackgroundType::Computer:
+            resRef += "comp" + std::to_string(computerType);
             break;
         default:
             return;
diff --git a/src/libs/resource/provider/dialogs.cpp b/src/libs/resource/provider/dialogs.cpp
index b29494a50..e9de28154 100644
--- a/src/libs/resource/provider/dialogs.cpp
+++ b/src/libs/resource/provider/dialogs.cpp
@@ -43,6 +43,7 @@ std::unique_ptr<Dialog> Dialogs::loadDialog(const resource::generated::DLG &dlg)
     dialog->endScript = dlg.EndConversation;
     dialog->abortScript = dlg.EndConverAbort;
     dialog->animatedCutscene = dlg.AnimatedCut;
+    dialog->entryDelay = dlg.DelayEntry;
     dialog->oldHitCheck = dlg.OldHitCheck != 0;
     dialog->conversationType = static_cast<ConversationType>(dlg.ConversationType);
     dialog->computerType = static_cast<ComputerType>(dlg.ComputerType);
@@ -101,6 +102,15 @@ Dialog::EntryReply Dialogs::getEntryReply(const resource::generated::DLG_EntryRe
     entry.actionParams2.str = dlg.ActionParamStrB;
     entry.delay = dlg.Delay;
     entry.waitFlags = dlg.WaitFlags;
+    entry.soundExists = (dlg.SoundExists & 1) != 0;
+    entry.nodeUnskippable = dlg.NodeUnskippable != 0;
+    // Fade types 1 and 2 cut at once.
+    static constexpr int kFirstCutFade = 1;
+    static constexpr int kLastCutFade = 2;
+    entry.fadeType = dlg.FadeType;
+    entry.fadeColor = dlg.FadeColor;
+    entry.fadeDelay = dlg.FadeDelay;
+    entry.fadeLength = entry.fadeType >= kFirstCutFade && entry.fadeType <= kLastCutFade ? 0.0f : dlg.FadeLength;
     entry.cameraId = dlg.CameraID;
     entry.cameraAngle = dlg.CameraAngle;
     entry.cameraAnimation = dlg.CameraAnimation;
diff --git a/test/game/computer.cpp b/test/game/computer.cpp
index d6a17ce5a..e1d37e596 100644
--- a/test/game/computer.cpp
+++ b/test/game/computer.cpp
@@ -69,6 +69,8 @@ std::shared_ptr<Dialog> computerDialog(bool camera = true, bool automatic = fals
     auto dialog = std::make_shared<Dialog>();
     dialog->resRef = "computer_test";
     dialog->conversationType = ConversationType::Computer;
+    // Returning from a camera shot is a skip.
+    dialog->skippable = true;
     dialog->startEntries.push_back({});
     dialog->entries.resize(2);
     dialog->replies.resize(3);
@@ -213,11 +215,12 @@ TEST_P(ComputerGUITest, return_auto_selects_empty_reply_once_without_replaying_s
 TEST_P(ComputerGUITest, return_preserves_entry_and_existing_multiple_replies) {
     auto dialog = computerDialog();
     computer->start(dialog, nullptr);
-    auto replies = computer->replies;
+    // The replies are listed when the entry ends.
+    EXPECT_TRUE(computer->replies.empty());
     EXPECT_TRUE(returnControl->isSelectable());
     returnControl->handleClick(0, 0, 1);
     EXPECT_EQ(computer->entry(), &dialog->entries[0]);
-    EXPECT_EQ(computer->replies, replies);
+    EXPECT_EQ(computer->replies.size(), 2u);
     EXPECT_EQ(computer->replyRefreshes, 1);
     EXPECT_EQ(computer->loads, 1);
     EXPECT_EQ(computer->ends, 1);
diff --git a/test/game/conversation.cpp b/test/game/conversation.cpp
index 8ed69872f..e968fd8f2 100644
--- a/test/game/conversation.cpp
+++ b/test/game/conversation.cpp
@@ -139,6 +139,7 @@ std::shared_ptr<Dialog> makeDialog(int firstEntryDelay = 1, bool voiced = false)
     firstEntry.replies.push_back(automaticReplyLink);
     if (voiced) {
         firstEntry.sound = "test_voice";
+        firstEntry.soundExists = true;
     }
 
     auto &automaticReply = dialog->replies[0];
@@ -450,8 +451,10 @@ TEST_F(ConversationTest, unpaused_automatic_skip_retains_immediate_progression)
     autoSkip.enabled = true;
     autoSkip.entries.push(true);
     _conversation->setAutoSkip(&autoSkip);
+    auto dialog = makeDialog();
+    dialog->skippable = true;
 
-    _conversation->start(makeDialog(), nullptr);
+    _conversation->start(dialog, nullptr);
 
     EXPECT_EQ("second", _conversation->currentText());
     EXPECT_EQ(2, _conversation->entryLoadCount());
@@ -492,6 +495,8 @@ TEST_F(ConversationTest, replacing_a_paused_conversation_starts_the_new_session_
 TEST_F(ConversationTest, finishing_a_paused_conversation_does_not_leak_pause_to_the_next_session) {
     startSilent();
     _conversation->update(1.0f);
+    // The second entry's reply is listed when it ends.
+    _conversation->update(100.0f);
     _conversation->pause();
 
     _conversation->pickReplyForTest(0);
@@ -503,7 +508,7 @@ TEST_F(ConversationTest, finishing_a_paused_conversation_does_not_leak_pause_to_
 
     EXPECT_EQ("second", _conversation->currentText());
     EXPECT_EQ(4, _conversation->entryLoadCount());
-    EXPECT_EQ(2, _conversation->entryEndCount());
+    EXPECT_EQ(3, _conversation->entryEndCount());
 }
 
 TEST_F(ConversationTest, finishing_leaves_a_screen_opened_by_a_reply_script_alone) {
@@ -512,6 +517,8 @@ TEST_F(ConversationTest, finishing_leaves_a_screen_opened_by_a_reply_script_alon
     // action -- so finishing must not pull the screen back to the world.
     startSilent();
     _conversation->update(1.0f);
+    // The second entry's reply is listed when it ends.
+    _conversation->update(100.0f);
 
     _conversation->pickReplyForTest(0);
 
@@ -562,7 +569,7 @@ TEST_F(ConversationTest, one_liner_presents_its_entry_and_completes_without_open
     EXPECT_EQ(1, _conversation->barkCount());
     EXPECT_EQ("bark", _conversation->currentText());
     EXPECT_EQ(Game::Screen::None, _game->currentScreen());
-    EXPECT_EQ(1, _conversation->entryLoadCount());
+    EXPECT_EQ(0, _conversation->entryLoadCount());
 }
 
 TEST_F(ConversationTest, completed_one_liner_does_not_run_its_actions_a_second_time) {
@@ -598,7 +605,7 @@ TEST_F(ConversationTest, one_liner_entry_action_starting_a_conversation_keeps_th
     // is live and presented by itself: the old one must not have gone on to
     // reload or otherwise drive it.
     EXPECT_EQ("first", _conversation->currentText());
-    EXPECT_EQ(2, _conversation->entryLoadCount());
+    EXPECT_EQ(1, _conversation->entryLoadCount());
     EXPECT_EQ(1, _conversation->barkCount());
     _conversation->update(1.0f);
     EXPECT_EQ("second", _conversation->currentText());
@@ -676,7 +683,7 @@ TEST_F(ConversationTest, same_resource_entry_replacement_does_not_execute_old_se
         }));
     EXPECT_CALL(_engine.resourceModule().scripts(), get("second_action")).Times(1).WillOnce(Return(nullptr));
     _conversation->start(dialog, nullptr);
-    EXPECT_EQ(1, _conversation->entryLoadCount());
+    EXPECT_EQ(2, _conversation->entryLoadCount());
     EXPECT_TRUE(fade.heldForDialog());
     EXPECT_FLOAT_EQ(1, fade.opacity());
 }
@@ -716,7 +723,9 @@ TEST_F(ConversationTest, reply_condition_replacement_cannot_consume_replacement_
             return nullptr;
         }));
     _conversation->start(dialog, nullptr);
-    EXPECT_EQ(1, _conversation->entryLoadCount());
+    // The reply's condition is tested as the entry ends.
+    _conversation->update(1.0f);
+    EXPECT_EQ(2, _conversation->entryLoadCount());
     EXPECT_TRUE(fade.heldForDialog());
 }
 
diff --git a/test/game/object.cpp b/test/game/object.cpp
index 76cfed1b9..b2c6b591e 100644
--- a/test/game/object.cpp
+++ b/test/game/object.cpp
@@ -195,7 +195,7 @@ class MixedStuntTestAccess {
             return false;
         }
         auto cut = DialogGUI::decodeCutAnimation(ordinal);
-        return gui.enterMixedStunt(gui._participantByTag.at(tag), animation, cut && cut->looping);
+        return gui.enterMixedStunt(gui._participantByTag.at(tag), animation, cut && cut->looping, ordinal);
     }
 
     static std::optional<DialogGUI::CutAnimation> decodeCut(int ordinal) {
@@ -1298,18 +1298,19 @@ TEST(Creature, should_activate_and_deactivate_lightsabers_in_both_hands_with_com
     EXPECT_EQ(leftSaberNode->activeAnimationName(), "powerdown");
 }
 
-TEST(Conversation, should_advance_script_only_auto_routing_entry_without_presenting_it) {
+TEST(Conversation, should_show_script_only_auto_routing_entry_and_advance_at_the_next_update) {
     TestEngine &engine = testEngine();
     StubConsole console;
     Game game(GameID::KotOR, "", engine.options(), engine.services(), console);
     RoutingConversation conversation(game, engine.services());
 
     conversation.start(makeRoutingDialog(), nullptr);
+    conversation.update(0.0f);
 
     ASSERT_EQ(conversation.messages.size(), 2);
     EXPECT_EQ(conversation.messages[0], "");
     EXPECT_EQ(conversation.messages[1], "visible");
-    EXPECT_EQ(conversation.presentedEntryCount, 1);
+    EXPECT_EQ(conversation.presentedEntryCount, 2);
 }
 
 TEST(Conversation, should_present_auto_routing_entry_with_authored_presentation_data) {
@@ -7099,7 +7100,11 @@ class AdmissionDialogGUI : public DialogGUI {
     }
 
     void update(float dt) override { Conversation::update(dt); }
-    void chooseReply() { pickReply(0); }
+    // The replies are listed when the entry ends.
+    void chooseReply() {
+        endCurrentEntry();
+        pickReply(0);
+    }
     int entries {0};
 
 private:

From aa86f543af8e70ed5276eab92ce778a1d2aff1ac Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:30:43 -0400
Subject: [PATCH 05/23] - #6 FIXED: the character sheet takes the experience
 table's amount at the   leader's level up to and including the cap, shows it
 unless it is   0xFFFFFFFF, and prints it signed; isLevelUpPending keeps its
 own cap test. - #7 FIXED: giveXP caps the lagging classes at five (nothing
 kept) and   refuses only a positive addition past the most experience,
 including on a   total held past it; SetXP ignores a negative amount and
 compares unsigned. - #8 FIXED: IsPC is kept as the record's byte;
 potentialLevel walks the   table only when it is exactly 1, else gives
 getSpellLevel(false), so TSL's   G_PC_LEVEL follows.

---
 include/reone/game/object/creature.h       | 50 +++++++++++++++++-----
 src/libs/game/action/commands.cpp          |  2 +-
 src/libs/game/attack.cpp                   |  2 +-
 src/libs/game/effect/creaturestate.cpp     |  4 +-
 src/libs/game/effect/modifiers.cpp         |  2 +-
 src/libs/game/equipmentoperation.cpp       |  2 +-
 src/libs/game/equipmentrules.cpp           |  2 +-
 src/libs/game/gui/ingame/character.cpp     | 14 +++---
 src/libs/game/object/area.cpp              |  4 +-
 src/libs/game/object/creature.cpp          | 37 ++++++++++------
 src/libs/game/object/encounter.cpp         |  2 +-
 src/libs/game/party.cpp                    |  2 +-
 src/libs/game/script/routine/impl/main.cpp | 18 ++++----
 13 files changed, 92 insertions(+), 49 deletions(-)

diff --git a/include/reone/game/object/creature.h b/include/reone/game/object/creature.h
index eb9c854a6..0a02de450 100644
--- a/include/reone/game/object/creature.h
+++ b/include/reone/game/object/creature.h
@@ -575,9 +575,10 @@ class Creature : public Object, public scene::IAnimationEventListener {
      * Adds experience. With two or more classes, every class other than the
      * favoured one that is two or more levels below the highest of those
      * classes takes a fifth of the amount, rounded down. A race without a
-     * favoured class favours the highest-level class, the earliest on a tie.
-     * Experience only grows: a negative amount, or one that would take it
-     * past kMaxExperience, changes nothing.
+     * favoured class favours the highest-level class, the earliest on a tie;
+     * five or more such classes take the whole amount. Experience only
+     * grows: a negative amount, or a positive one that would take it past
+     * kMaxExperience, changes nothing.
      */
     void giveXP(int amount);
     void setXP(int xp);
@@ -783,13 +784,18 @@ class Creature : public Object, public scene::IAnimationEventListener {
     /** The level-up chime may still sound for the creature: from its creation, and again after each level-up. */
     bool isLevelUpChimeArmed() const { return _levelUpChimeArmed; }
     void setLevelUpChimeArmed(bool armed) { _levelUpChimeArmed = armed; }
-    /** The level the creature's experience reaches by the experience table, up to the title's maximum. */
+    /**
+     * The level the creature's experience reaches by the experience table, up
+     * to the title's maximum, for a creature whose IsPC is exactly 1; any
+     * other creature's level, as getSpellLevel(false) gives it.
+     */
     int potentialLevel() const;
 
     glm::vec3 getSelectablePosition() const override;
     /**
-     * The experience the creature's level needs for the next, from the
-     * experience table; none at or past the title's maximum level.
+     * The experience table's amount at the creature's level, up to and
+     * including the title's maximum level; none past it. The maximum level's
+     * row normally holds 0xFFFFFFFF, the amount no experience reaches.
      */
     std::optional<uint32_t> getNeededXP() const;
     /**
@@ -958,7 +964,22 @@ class Creature : public Object, public scene::IAnimationEventListener {
     /** The creature scripts name for this one to heal. It is not saved. */
     uint32_t healTarget() const { return _healTarget; }
     void setHealTarget(uint32_t target) { _healTarget = target; }
-    bool isPC() const { return _isPC; }
+    /**
+     * Whether the creature's record marks it a player character: its IsPC is
+     * not 0. The record's value is saved with the creature.
+     */
+    bool isPC() const { return _isPC != 0; }
+    /** The record's IsPC as stored, 0 to 255; a player character's is 1. */
+    int isPCValue() const { return _isPC; }
+    /**
+     * Whether the creature acts as a player character: its own copy of the
+     * record's IsPC, taken whenever the record is read, cleared when an
+     * encounter spawns the creature, and set with the record's when control
+     * of the party changes hands. The copy is not 0.
+     */
+    bool actsAsPC() const { return _actsAsPC != 0; }
+    /** The creature's own copy of IsPC as it stands, 0 to 255. */
+    int actsAsPCValue() const { return _actsAsPC; }
     /** Whether a click to talk leaves the creature facing the way it was. */
     bool isNotReorienting() const { return _notReorienting; }
     /** The character was made by the player (TSL item limitation). */
@@ -970,10 +991,14 @@ class Creature : public Object, public scene::IAnimationEventListener {
     void forceEquipClothing();
     void setPlayerCreated(bool value) { _playerCreated = value; }
     /**
-     * The player-character flag a creature record carries as IsPC. A creature
-     * whose record does not carry it is a player character.
+     * Sets the player-character flag, both the record's IsPC and the
+     * creature's own copy, to 1 or 0. A creature whose record does not carry
+     * IsPC is a player character.
      */
-    void setPC(bool value) { _isPC = value; }
+    void setPC(bool value) {
+        _isPC = value ? 1 : 0;
+        _actsAsPC = _isPC;
+    }
     /** The appearance's race label, which picks droid discharges. */
     const std::string &appearanceRace() const { return _appearanceRace; }
     /** The appearance's blood colour: R, G, Y or none. */
@@ -2342,7 +2367,10 @@ class Creature : public Object, public scene::IAnimationEventListener {
     bool _disguised {false};
     Gender _gender {Gender::Male};
     uint16_t _portraitId {0};
-    bool _isPC {true};
+    /** The record's IsPC byte; any value but 0 marks a player character. */
+    uint8_t _isPC {1};
+    /** The creature's own copy of IsPC (see actsAsPC()); not saved. */
+    uint8_t _actsAsPC {1};
     bool _playerCreated {false};
     /** Body armour this creature could not wear when it was loaded. */
     bool _bodyRefusedOnLoad {false};
diff --git a/src/libs/game/action/commands.cpp b/src/libs/game/action/commands.cpp
index df64a9742..09f63d1a0 100644
--- a/src/libs/game/action/commands.cpp
+++ b/src/libs/game/action/commands.cpp
@@ -304,7 +304,7 @@ std::shared_ptr<Action> WaitAction::restore(const SavedActionRecord &record, Gam
 // surrender fails.
 void SurrenderToEnemiesAction::execute(std::shared_ptr<Action> self, Object &actor, float dt) {
     auto &creature = static_cast<Creature &>(actor);
-    if (!creature.isPC()) {
+    if (creature.actsAsPCValue() != 1) {
         creature.surrenderToEnemies(false);
     }
     complete();
diff --git a/src/libs/game/attack.cpp b/src/libs/game/attack.cpp
index daae2ff36..dfc735af9 100644
--- a/src/libs/game/attack.cpp
+++ b/src/libs/game/attack.cpp
@@ -3309,7 +3309,7 @@ AttackApproachStep approachAttackTarget(Creature &attacker, Object &target, floa
     const bool sight = area.isEyeLineClear(eye, targetEye, attacker, target, rightHand && rightHand->isRanged());
     if (sight) {
         attacker.clearBlockedAttackSight();
-    } else if (attacker.noteBlockedAttackSight() && attacker.isPC()) {
+    } else if (attacker.noteBlockedAttackSight() && attacker.actsAsPC()) {
         // The player character gives up a target it cannot see; the line
         // reaches the player only while controlling it.
         if (game.party().getLeader().get() == &attacker) {
diff --git a/src/libs/game/effect/creaturestate.cpp b/src/libs/game/effect/creaturestate.cpp
index 2e12a2cbe..574d16946 100644
--- a/src/libs/game/effect/creaturestate.cpp
+++ b/src/libs/game/effect/creaturestate.cpp
@@ -353,7 +353,7 @@ void CreatureStateInternalEffect::onRemove(Object &object, const EffectInstance
         creature->onInternalStateRemoved(instance.id, stateRemovalAppliesPose(state, object.game().isTSL()));
         // A creature other than a player character forgets what it perceived
         // and looks around anew.
-        if (!creature->isPC()) {
+        if (!creature->actsAsPC()) {
             creature->perceiveAfresh();
         }
     }
@@ -711,7 +711,7 @@ EffectApplicationResult EntangleEffect::onApply(Object &object, EffectInstance &
 }
 
 void EntangleEffect::onRemove(Object &object, const EffectInstance &) {
-    if (auto *creature = dyn_cast<Creature>(&object); creature && !creature->isPC()) {
+    if (auto *creature = dyn_cast<Creature>(&object); creature && !creature->actsAsPC()) {
         creature->perceiveAfresh();
     }
 }
diff --git a/src/libs/game/effect/modifiers.cpp b/src/libs/game/effect/modifiers.cpp
index a55324ed1..f84088375 100644
--- a/src/libs/game/effect/modifiers.cpp
+++ b/src/libs/game/effect/modifiers.cpp
@@ -737,7 +737,7 @@ EffectApplicationResult DisguiseEffect::onApply(Object &object, EffectInstance &
 
 void DisguiseEffect::onRemove(Object &object, const EffectInstance &) {
     auto *creature = dyn_cast<Creature>(&object);
-    if (!creature || (creature->isDead() && !creature->isPC() && object.isDestroyable())) {
+    if (!creature || (creature->isDead() && !creature->actsAsPC() && object.isDestroyable())) {
         return;
     }
     creature->removeDisguiseAppearance();
diff --git a/src/libs/game/equipmentoperation.cpp b/src/libs/game/equipmentoperation.cpp
index d51539ef6..a7cedfe13 100644
--- a/src/libs/game/equipmentoperation.cpp
+++ b/src/libs/game/equipmentoperation.cpp
@@ -86,7 +86,7 @@ static EquipmentOperationOutcome equipFrom(
     // Refusals and replacements are reported to the controlled creature only.
     const bool controlled = game.party().getLeader().get() == &subject;
     // The player character must reach the item's level before anything else.
-    if (subject.isPC() && subject.attributes().getAggregateLevel() < minimumEquipLevel(subject, *item)) {
+    if (subject.isPCValue() == 1 && subject.attributes().getAggregateLevel() < minimumEquipLevel(subject, *item)) {
         if (controlled) {
             game.addFeedbackMessage(*equipmentRefusalFeedback(EquipmentCandidateReason::MinimumLevel));
         }
diff --git a/src/libs/game/equipmentrules.cpp b/src/libs/game/equipmentrules.cpp
index 187adf3a4..0daa533da 100644
--- a/src/libs/game/equipmentrules.cpp
+++ b/src/libs/game/equipmentrules.cpp
@@ -334,7 +334,7 @@ bool canUseItem(const Creature &creature, const Item &item, bool menuCheck) {
     if (tsl && (!meetsGenderLimits(creature, item) || !meetsPlayerCharacterLimits(creature, item) ||
                 !meetsAttributeLimits(creature, item) || isExcludedForCreature(creature, item)))
         return false;
-    if (creature.isPC() && creature.attributes().getAggregateLevel() < minimumEquipLevel(creature, item)) {
+    if (creature.isPCValue() == 1 && creature.attributes().getAggregateLevel() < minimumEquipLevel(creature, item)) {
         return false;
     }
     // A weapon may be at most one size larger than its user, unless it may be
diff --git a/src/libs/game/gui/ingame/character.cpp b/src/libs/game/gui/ingame/character.cpp
index 8add4fa4e..cbd0709c5 100644
--- a/src/libs/game/gui/ingame/character.cpp
+++ b/src/libs/game/gui/ingame/character.cpp
@@ -50,6 +50,9 @@ namespace game {
 // The tutorial window (tutorial.2da row) the AI script panel asks for.
 static constexpr int kScriptSelectTutorial = 10;
 
+/** The experience table's amount for a level no experience reaches. */
+static constexpr uint32_t kUnreachableExperience = 0xFFFFFFFF;
+
 // The Force mastery lines, one per group of Jedi and Sith classes, for Pure
 // Good and for Pure Evil powers.
 static constexpr int kStrRefGuardianPureGood = 114161;
@@ -320,14 +323,15 @@ void CharacterMenu::refreshControls() {
     _controls.LBL_WILL_STAT->setTextMessage(std::to_string(savingThrows.will));
 
     _controls.LBL_EXPERIENCE_STAT->setTextMessage(std::to_string(partyLeader->xp()));
-    // Past the title's level cap the experience the next level needs is
-    // hidden.
+    // The experience table's amount at the leader's level prints signed; it
+    // is hidden when the table holds the unreachable amount there.
     const auto needed = partyLeader->getNeededXP();
     if (needed) {
-        _controls.LBL_NEEDED_XP->setTextMessage(std::to_string(*needed));
+        _controls.LBL_NEEDED_XP->setTextMessage(std::to_string(static_cast<int>(*needed)));
     }
-    _controls.LBL_NEEDED_XP->setVisible(needed.has_value());
-    _controls.LBL_NEXT_LEVEL->setVisible(needed.has_value());
+    const bool neededShown = needed && *needed != kUnreachableExperience;
+    _controls.LBL_NEEDED_XP->setVisible(neededShown);
+    _controls.LBL_NEXT_LEVEL->setVisible(neededShown);
 
     if (_game.isTSL()) {
         refreshForceMastery(*partyLeader);
diff --git a/src/libs/game/object/area.cpp b/src/libs/game/object/area.cpp
index d8811106a..df55eebb5 100644
--- a/src/libs/game/object/area.cpp
+++ b/src/libs/game/object/area.cpp
@@ -1630,7 +1630,7 @@ std::shared_ptr<Creature> Area::findFactionMember(Faction faction, int pc, size_
         return left->factionJoinOrder() < right->factionJoinOrder();
     });
     for (size_t index = from; index < members.size(); ++index) {
-        if (static_cast<int>(members[index]->isPC()) != pc) {
+        if (members[index]->isPCValue() != pc) {
             continue;
         }
         _factionMemberCursors[faction] = index + 1;
@@ -3476,7 +3476,7 @@ bool Area::matchesCriterias(const Creature &creature, const SearchCriteriaList &
             matched = matchesRace(creature, firstValue, value);
             break;
         case CreatureType::PlayerChar:
-            matched = static_cast<int>(creature.isPC()) == value;
+            matched = creature.isPCValue() == value;
             break;
         case CreatureType::Class:
             matched = matchesClass(creature, value);
diff --git a/src/libs/game/object/creature.cpp b/src/libs/game/object/creature.cpp
index 2eda10209..8e51b02f5 100644
--- a/src/libs/game/object/creature.cpp
+++ b/src/libs/game/object/creature.cpp
@@ -1191,7 +1191,7 @@ static void applyDeathExperience(
 
     // A player character or party member is worth nothing. Reputation queries
     // from an NPC faction to faction zero use the player row.
-    if (victim.isPC() || game.party().isMember(victim) ||
+    if (victim.actsAsPC() || game.party().isMember(victim) ||
         services.game.reputes.getReputation(Faction::Player, victim.faction()) > 10)
         return;
     // The award is measured against the experience of the creature under the
@@ -1927,7 +1927,7 @@ void Creature::perceiveAfresh() {
     for (const uint32_t id : perceived) {
         forgetPerceived(id);
     }
-    if (!_isPC && isDead()) {
+    if (!actsAsPC() && isDead()) {
         return;
     }
     _game.module()->area()->perceiveNow(_game.getObjectById<Creature>(_id));
@@ -3390,7 +3390,7 @@ int Creature::maxHitPoints() const {
     const auto hasVitalityFeat = [this](FeatType feat) { return hasEffectiveFeat(feat); };
     // The player character's level history holds while no companion is
     // controlled in its place.
-    return _isPC && _game.party().controlledNpc() == -1
+    return _isPC == 1 && _game.party().controlledNpc() == -1
                ? _attributes.getLevelHistoryMaxHitPoints(
                      [this](int level) {
                          // A level without a recorded entry grants no hit die.
@@ -3410,7 +3410,7 @@ void Creature::refreshVitalityConstitution() {
 bool Creature::hitPointsAtDeathThreshold() const {
     // A party member is never dead by its vitality alone; a player character
     // dies at -10, any other creature at 0.
-    return !_game.party().isMember(*this) && currentHitPoints() <= (_isPC ? -10 : 0);
+    return !_game.party().isMember(*this) && currentHitPoints() <= (actsAsPC() ? -10 : 0);
 }
 
 void Creature::updateDeathFromCurrentHitPoints() {
@@ -3956,7 +3956,7 @@ int Creature::getReputationFrom(Faction sourceFaction) const {
 
 void Creature::joinEncounter(const Encounter &encounter) {
     _encounterId = encounter.id();
-    _isPC = false;
+    _actsAsPC = 0;
 }
 
 void Creature::leaveEncounter() {
@@ -4457,7 +4457,7 @@ bool Creature::applyResurrectionEffect(int hpPercent) {
 // The party always runs at the top priority; combat raises the lower
 // priorities to 2, and leaving combat drops 2 to 1.
 void Creature::updateAILevel() {
-    if (_isPC || isPartyMember()) {
+    if (_isPC == 1 || isPartyMember()) {
         _aiLevel = 4;
     } else if (_combatState.active && _aiLevel <= 1) {
         _aiLevel = 2;
@@ -5530,13 +5530,19 @@ bool Creature::isLevelUpPending() const {
     if (isDead() || isTemporarilyDead()) {
         return false;
     }
-    const auto needed = getNeededXP();
-    return needed && static_cast<uint32_t>(_xp) >= *needed;
+    const int level = _attributes.getAggregateLevel();
+    return level < maxCharacterLevel(_game.isTSL()) &&
+           static_cast<uint32_t>(_xp) >= _services.game.combatTables.experienceThreshold(level);
 }
 
+// Only a creature whose IsPC is exactly 1 walks the table; any other keeps
+// its level.
 int Creature::potentialLevel() const {
     const auto &tables = _services.game.combatTables;
-    int level = _attributes.getAggregateLevel();
+    int level = getSpellLevel(false);
+    if (_isPC != 1) {
+        return level;
+    }
     while (level < maxCharacterLevel(_game.isTSL()) &&
            static_cast<uint32_t>(_xp) >= tables.experienceThreshold(level)) {
         ++level;
@@ -5546,7 +5552,7 @@ int Creature::potentialLevel() const {
 
 std::optional<uint32_t> Creature::getNeededXP() const {
     const int level = _attributes.getAggregateLevel();
-    if (level >= maxCharacterLevel(_game.isTSL())) {
+    if (level > maxCharacterLevel(_game.isTSL())) {
         return std::nullopt;
     }
     return _services.game.combatTables.experienceThreshold(level);
@@ -5639,7 +5645,8 @@ void Creature::runConversationScript() {
 }
 
 // An addition that would lower the experience, or pass the most it holds,
-// is refused.
+// is refused. A total held past the most, read from a save, takes no
+// positive addition.
 void Creature::giveXP(int amount) {
     if (amount < 0) {
         return;
@@ -5665,8 +5672,9 @@ void Creature::giveXP(int amount) {
             }
         }
     }
+    behind = std::min(behind, 5);
     const auto kept = static_cast<int>(int64_t {amount} * (5 - behind) / 5);
-    if (kept > kMaxExperience - _xp) {
+    if (kept > 0 && (_xp < 0 || kept > kMaxExperience - _xp)) {
         return;
     }
     setXP(_xp + kept);
@@ -6477,7 +6485,7 @@ void Creature::setOrderedAttackTarget(uint32_t target) {
 void Creature::recordQueuedAttack(Object &target) {
     if (auto *creature = dyn_cast<Creature>(&target)) {
         const auto leader = _game.party().getLeader();
-        if (creature->isPC() || leader.get() == creature) {
+        if (creature->actsAsPCValue() == 1 || leader.get() == creature) {
             creature->_incomingAttacker = SavedObjectReference::fromRuntimeId(id());
             _game.bindSavedObjectReference(creature->_incomingAttacker);
         }
@@ -10319,7 +10327,8 @@ void Creature::deserializeAll(
 
     // IsPC is read before hit points are rebuilt. A player character stays
     // incapacitated and resumable through 0..-9 HP and is dead only at -10 HP.
-    gff.readBool(_isPC, "IsPC");
+    gff.readByte(_isPC, "IsPC");
+    _actsAsPC = _isPC;
     gff.readBool(_playerCreated, "PlayerCreated");
     // Only the value 1 is stealth.
     setStealthMode(gff.getUint("StealthMode", _stealthMode ? 1 : 0) == 1);
diff --git a/src/libs/game/object/encounter.cpp b/src/libs/game/object/encounter.cpp
index 7c7a9ec85..9f5a6b3b5 100644
--- a/src/libs/game/object/encounter.cpp
+++ b/src/libs/game/object/encounter.cpp
@@ -626,7 +626,7 @@ float Encounter::tallyHostilePoints() const {
             continue;
         }
         int level = creature.attributes().getAggregateLevel();
-        if (!creature.isPC()) {
+        if (!creature.actsAsPC()) {
             level >>= 1;
         }
         points += creaturePoints(static_cast<float>(level));
diff --git a/src/libs/game/party.cpp b/src/libs/game/party.cpp
index c620b0bb0..e135dcd29 100644
--- a/src/libs/game/party.cpp
+++ b/src/libs/game/party.cpp
@@ -1331,7 +1331,7 @@ bool Party::setPartyLeader(int npc) {
         // raiseable.
         for (const auto &member : _members) {
             const auto &creature = member.creature;
-            if (!creature || !creature->isPC()) {
+            if (!creature || creature->actsAsPCValue() != 1) {
                 continue;
             }
             if (creature->isTemporarilyDead()) {
diff --git a/src/libs/game/script/routine/impl/main.cpp b/src/libs/game/script/routine/impl/main.cpp
index 5bed1add0..b85763211 100644
--- a/src/libs/game/script/routine/impl/main.cpp
+++ b/src/libs/game/script/routine/impl/main.cpp
@@ -2718,10 +2718,12 @@ static Variable GetIsPC(const std::vector<Variable> &args, const RoutineContext
     // Transform
     auto creature = checkCreature(oCreature);
 
-    // Execute: TSL reads the creature's own player-character flag; KotOR
-    // asks whether it is the creature the player controls.
-    const bool pc = ctx.game.isTSL() ? creature->isPC() : creature == ctx.game.party().getLeader();
-    return Variable::ofInt(static_cast<int>(pc));
+    // Execute: TSL returns the record's IsPC as stored; KotOR asks whether
+    // it is the creature the player controls.
+    if (ctx.game.isTSL()) {
+        return Variable::ofInt(creature->isPCValue());
+    }
+    return Variable::ofInt(static_cast<int>(creature == ctx.game.party().getLeader()));
 }
 
 static Variable FeetToMeters(const std::vector<Variable> &args, const RoutineContext &ctx) {
@@ -4391,9 +4393,9 @@ static Variable SetXP(const std::vector<Variable> &args, const RoutineContext &c
     // Transform
     auto creature = checkCreature(oCreature);
 
-    // Execute: only the named creature changes, and a script cannot lower
-    // its experience.
-    if (nXpAmount >= creature->xp()) {
+    // Execute: only the named creature changes, a negative amount is ignored,
+    // and a script cannot lower its experience; experience compares unsigned.
+    if (nXpAmount >= 0 && static_cast<uint32_t>(nXpAmount) >= static_cast<uint32_t>(creature->xp())) {
         creature->setXP(nXpAmount);
     }
     return Variable::ofNull();
@@ -5877,7 +5879,7 @@ static Variable GetFactionLeader(const std::vector<Variable> &args, const Routin
             continue;
         }
         if (!npcFaction) {
-            if (member->isPC()) {
+            if (member->actsAsPC()) {
                 return Variable::ofObject(member->id());
             }
             continue;

From f61560c3e7c5bb95a4d0fe3ef3e43941283d469a Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:31:13 -0400
Subject: [PATCH 06/23] - #3 FIXED (pulse): a selected Button's or
 ToggleButton's text pulses, and   an ImageButton's where the GUI says so
 (TSL: every GUI, the HUD and the   save-name box). The abilities rows'
 per-screen call is gone. The colour   part (TSL COLOR_NEW_HIGHLIGHT, K1
 label-hilights keeping theirs) stays   with PR 12's hilight text colour; K1
 buttons are already yellow. - #14 FIXED: deselecting such a control stops its
 text's pulse, except a   list's prototype, which is reselected for every row.
 - #17 FIXED: setHilightPulsing leaves a control without a hilight alone. - #9
 FIXED: one alpha per border; _borderFillOpacity is gone, the HUD's   idle
 queue slot sets the border alpha, and a pulse replaces it. - #13 FIXED: a
 progress bar's PROGRESS is a border; its fill pulses as   authored. - #15
 FIXED: the pulse clock ticks after the death sequence, at its time   scale. -
 #5 FIXED: the map screen's party arrow is drawn at the pulsing alpha;   the
 minimap's stays steady. - #4 FIXED: the current chargen/level-up step's
 number and name pulse, and   pulse again when the steps panel returns;
 chargen points rows pulse   while hovered; the pause reason and prompt pulse;
 the character sheet's   level-up buttons pulse until first left. The
 difficulty text is a   Button, so #3 covers it.

---
 include/reone/game/game.h                  | 12 ++------
 include/reone/game/gui/chargen/abilities.h |  3 +-
 include/reone/game/gui/chargen/custom.h    |  6 ++++
 include/reone/game/gui/chargen/levelup.h   |  6 ++++
 include/reone/game/gui/chargen/quick.h     |  6 ++++
 include/reone/game/gui/chargen/skills.h    |  3 +-
 include/reone/game/gui/map.h               |  6 ++--
 include/reone/gui/control.h                | 16 +++++-----
 include/reone/gui/control/progressbar.h    | 13 ++++-----
 include/reone/gui/gui.h                    | 15 +++++++++-
 include/reone/gui/guis.h                   |  2 +-
 src/libs/game/game.cpp                     | 34 +++++-----------------
 src/libs/game/gui/chargen.cpp              |  3 ++
 src/libs/game/gui/chargen/abilities.cpp    | 17 ++++++-----
 src/libs/game/gui/chargen/custom.cpp       | 14 +++++++++
 src/libs/game/gui/chargen/levelup.cpp      | 12 ++++++++
 src/libs/game/gui/chargen/quick.cpp        |  8 +++++
 src/libs/game/gui/chargen/skills.cpp       | 21 +++++++------
 src/libs/game/gui/hud.cpp                  |  8 +++--
 src/libs/game/gui/ingame/abilities.cpp     |  4 +--
 src/libs/game/gui/ingame/character.cpp     |  3 ++
 src/libs/game/gui/ingame/inventory.cpp     |  3 --
 src/libs/game/gui/ingame/map.cpp           |  2 +-
 src/libs/game/gui/map.cpp                  | 13 +++++----
 src/libs/game/gui/saveload.cpp             |  1 +
 src/libs/game/presentationgui.cpp          |  4 ++-
 src/libs/gui/control.cpp                   | 17 +++++++++--
 src/libs/gui/control/progressbar.cpp       | 14 ++++-----
 test/fixtures/gui.h                        |  2 ++
 29 files changed, 172 insertions(+), 96 deletions(-)

diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 34a42bfb2..9e23e3e61 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -1861,17 +1861,11 @@ class Game : boost::noncopyable {
     bool _showEndGameGui {true};
     uint32_t _lastPartyMemberTempKilled {script::kObjectInvalid};
     /**
-     * How fast the world, its presentation and the fade run during the death
-     * sequence. The first title slows play from full speed to a fifth over
-     * the first four seconds of real time; its time and rate carry over to
-     * later deaths for the program's lifetime. The second title runs at a quarter
-     * while its gameover panel is up.
+     * How fast the world, its presentation and the fade run: a quarter while
+     * the second title's gameover panel is up, else full speed. The first
+     * title's death sequence keeps full speed.
      */
     float _deathTimeScale {1.0f};
-    uint32_t _deathSequenceSample {0};
-    float _deathSequenceSeconds {0.0f};
-    float _deathSlowRate {0.0f};
-    bool _deathSequenceStarting {true};
     std::unique_ptr<ContainerGUI> _container;
     std::unique_ptr<PartySelection> _partySelect;
     std::unique_ptr<SaveLoad> _saveLoad;
diff --git a/include/reone/game/gui/chargen/abilities.h b/include/reone/game/gui/chargen/abilities.h
index e95669d12..d6411777b 100644
--- a/include/reone/game/gui/chargen/abilities.h
+++ b/include/reone/game/gui/chargen/abilities.h
@@ -158,7 +158,8 @@ class CharGenAbilities : public GameGUI {
 
     int getPointCost(Ability ability) const;
 
-    void onAbilityLabelSelectionChanged(Ability ability, bool selected);
+    /** Pulses the row's name and points while the row is hovered, and describes its ability. */
+    void onAbilityLabelSelectionChanged(Ability ability, gui::Label &label, gui::Button &points, bool selected);
     void onMinusButtonClick(Ability ability);
     void onPlusButtonClick(Ability ability);
 };
diff --git a/include/reone/game/gui/chargen/custom.h b/include/reone/game/gui/chargen/custom.h
index e095d2bc2..ac408e658 100644
--- a/include/reone/game/gui/chargen/custom.h
+++ b/include/reone/game/gui/chargen/custom.h
@@ -53,6 +53,12 @@ class CustomCharacterGeneration : public GameGUI {
 
     void setStep(int step);
 
+    /**
+     * Shows the current step as current again, its number and name pulsing,
+     * as when the panel returns from one of the steps' screens.
+     */
+    void refreshStep() { doSetStep(_step); }
+
 private:
     struct Controls {
         std::shared_ptr<gui::Button> BTN_BACK;
diff --git a/include/reone/game/gui/chargen/levelup.h b/include/reone/game/gui/chargen/levelup.h
index 67fbe8193..4b4616d20 100644
--- a/include/reone/game/gui/chargen/levelup.h
+++ b/include/reone/game/gui/chargen/levelup.h
@@ -53,6 +53,12 @@ class LevelUpMenu : public GameGUI {
 
     void setStep(int step);
 
+    /**
+     * Shows the current step as current again, its number and name pulsing,
+     * as when the panel returns from one of the steps' screens.
+     */
+    void refreshStep() { doSetStep(_step); }
+
     /** Whether the coming level offers a choice of feats. */
     bool hasFeatChoices() const;
     /** Whether the coming level offers a choice of powers. */
diff --git a/include/reone/game/gui/chargen/quick.h b/include/reone/game/gui/chargen/quick.h
index fde12ffa5..5ff46b859 100644
--- a/include/reone/game/gui/chargen/quick.h
+++ b/include/reone/game/gui/chargen/quick.h
@@ -53,6 +53,12 @@ class QuickCharacterGeneration : public GameGUI {
 
     void setStep(int step);
 
+    /**
+     * Shows the current step as current again, its number and name pulsing,
+     * as when the panel returns from one of the steps' screens.
+     */
+    void refreshStep() { doSetStep(_step); }
+
 private:
     struct Controls {
         std::shared_ptr<gui::Button> BTN_BACK;
diff --git a/include/reone/game/gui/chargen/skills.h b/include/reone/game/gui/chargen/skills.h
index c86e0d73a..83065131f 100644
--- a/include/reone/game/gui/chargen/skills.h
+++ b/include/reone/game/gui/chargen/skills.h
@@ -170,7 +170,8 @@ class CharGenSkills : public GameGUI {
 
     void onMinusButtonClick(SkillType skill);
     void onPlusButtonClick(SkillType skill);
-    void onSkillLabelSelectionChanged(SkillType skill, bool selected);
+    /** Pulses the row's name and points while the row is hovered, and describes its skill. */
+    void onSkillLabelSelectionChanged(SkillType skill, gui::Label &label, gui::Button &points, bool selected);
 };
 
 } // namespace game
diff --git a/include/reone/game/gui/map.h b/include/reone/game/gui/map.h
index 5152a7f2f..0d6eba84a 100644
--- a/include/reone/game/gui/map.h
+++ b/include/reone/game/gui/map.h
@@ -51,12 +51,14 @@ class Map {
 
     /**
      * @param scale the factor the owning GUI draws its layout at.
+     * @param pulsingAlpha the owning GUI's pulsing alpha, which the party
+     *                     leader's arrow is drawn at on the map screen.
      *
      * The map and its markers are drawn into a control's rect but not by the
      * control, so nothing else carries the layout scale to them: the frame
      * shrank with the GUI while the map inside it stayed unscaled.
      */
-    void render(Mode mode, const glm::vec4 &bounds, float scale);
+    void render(Mode mode, const glm::vec4 &bounds, float scale, float pulsingAlpha);
 
     bool isLoaded() const { return static_cast<bool>(_areaTexture); }
 
@@ -83,7 +85,7 @@ class Map {
     void loadTextures(const std::string &area);
 
     void renderArea(Mode mode, const glm::vec4 &bounds, float scale);
-    void renderPartyLeader(Mode mode, const glm::vec4 &bounds, float scale);
+    void renderPartyLeader(Mode mode, const glm::vec4 &bounds, float scale, float pulsingAlpha);
     void renderNotes(Mode mode, const glm::vec4 &bounds, float scale);
 
     glm::vec2 getMapPosition(const glm::vec2 &world) const;
diff --git a/include/reone/gui/control.h b/include/reone/gui/control.h
index 893a4d42b..17780782c 100644
--- a/include/reone/gui/control.h
+++ b/include/reone/gui/control.h
@@ -114,7 +114,10 @@ class Control : boost::noncopyable {
         float opacity {1.0f};
         /** The text is drawn at the GUI's pulsing alpha. */
         bool pulsing {false};
-        /** While the control is selected, the text is drawn at the GUI's pulsing alpha. */
+        /**
+         * While the control is selected, the text is drawn at the GUI's pulsing
+         * alpha; deselecting the control stops the text's pulse.
+         */
         bool hilightPulsing {false};
     };
 
@@ -197,9 +200,9 @@ class Control : boost::noncopyable {
     void setText(Text text);
     void setTextAlignment(TextAlign align);
     void setTextColor(glm::vec3 color);
-    /** While selected, the text is drawn at the GUI's pulsing alpha. */
-    void setHilightTextPulsing(bool pulsing) { _text.hilightPulsing = pulsing; }
-    /** The hilight's frame and fill pulse, as chosen. */
+    /** Sets whether the text is drawn at the GUI's pulsing alpha. */
+    void setTextPulsing(bool pulsing) { _text.pulsing = pulsing; }
+    /** The hilight's frame and fill pulse, as chosen; a control without a hilight is left alone. */
     void setHilightPulsing(bool frame, bool fill);
     /** Sets the alpha the text is drawn with. */
     void setTextOpacity(float opacity) { _text.opacity = opacity; }
@@ -208,8 +211,6 @@ class Control : boost::noncopyable {
     void setTextPaddingLeft(int padding) { _textPaddingLeft = padding; }
     int textPaddingLeft() const;
     void setTintBorderFill(bool tint) { _tintBorderFill = tint; }
-    /** Sets the alpha the border's fill is drawn with. */
-    void setBorderFillOpacity(float opacity) { _borderFillOpacity = opacity; }
     void setSharpenBorderFillAlpha(bool sharpen) { _sharpenBorderFillAlpha = sharpen; }
     void setUseBorderColorOverride(bool use);
     void setVisible(bool visible);
@@ -275,8 +276,9 @@ class Control : boost::noncopyable {
     bool _selected {false};
     bool _hilightOverBorder {false};
     bool _selectable {false};
+    /** Whether this control is a list's prototype, drawn once for each row. */
+    bool _isProtoItem {false};
     bool _tintBorderFill {false};
-    float _borderFillOpacity {1.0f};
     bool _sharpenBorderFillAlpha {false};
     glm::vec3 _borderColorOverride {1.0f};
     bool _useBorderColorOverride {false};
diff --git a/include/reone/gui/control/progressbar.h b/include/reone/gui/control/progressbar.h
index fe2214371..fe8edcf3c 100644
--- a/include/reone/gui/control/progressbar.h
+++ b/include/reone/gui/control/progressbar.h
@@ -44,13 +44,12 @@ class ProgressBar : public Control {
     void setValue(int value);
 
 private:
-    struct Progress {
-        std::shared_ptr<graphics::Texture> fill;
-        /** Multiplies the fill. TSL authors greyscale bars and colours them here. */
-        glm::vec3 color {1.0f};
-    };
-
-    Progress _progress;
+    /**
+     * The bar drawn over the border up to the value. Its colour multiplies the
+     * fill: TSL authors greyscale bars and colours them here. Its fill pulses
+     * as authored.
+     */
+    std::shared_ptr<Border> _progress;
     int _value {0};
     bool _startFromLeft {true};
 };
diff --git a/include/reone/gui/gui.h b/include/reone/gui/gui.h
index ff9ba5557..f310ac850 100644
--- a/include/reone/gui/gui.h
+++ b/include/reone/gui/gui.h
@@ -55,7 +55,7 @@ class IGUIEventListener {
  */
 class PulsingAlpha {
 public:
-    /** Advances the pulse by dt seconds of real time. */
+    /** Advances the pulse by dt seconds. */
     void update(float dt) {
         _timeLeft -= dt;
         if (_timeLeft <= 0.0f) {
@@ -135,6 +135,8 @@ class IGUI {
     virtual float borderScale() const = 0;
     virtual float listScale() const = 0;
     virtual bool tintBorderFills() const = 0;
+    /** Whether an image button's text pulses while the button is selected, as a button's does. */
+    virtual bool imageButtonTextPulses() const = 0;
     /** The opacity pulsing borders and texts are drawn with now. */
     virtual float pulsingAlpha() const = 0;
 
@@ -146,6 +148,8 @@ class IGUI {
     virtual void setScaling(ScalingMode scaling) = 0;
     virtual void setTextScale(float scale) = 0;
     virtual void setTintBorderFills(bool tint) = 0;
+    /** Sets whether the image buttons loaded afterwards pulse their text while selected. */
+    virtual void setImageButtonTextPulses(bool pulses) = 0;
     virtual void setControlScaling(const std::string &tag, ScalingMode scaling) = 0;
     virtual void setDefaultHilightColor(glm::vec3 color) = 0;
     virtual void setBackground(std::shared_ptr<graphics::Texture> texture) = 0;
@@ -234,6 +238,10 @@ class GUI : public IGUI, boost::noncopyable {
         _tintBorderFills = tint;
     }
 
+    void setImageButtonTextPulses(bool pulses) override {
+        _imageButtonTextPulses = pulses;
+    }
+
     float textScale() const override {
         return _textScale.value_or(_options.guiTextScale);
     }
@@ -257,6 +265,10 @@ class GUI : public IGUI, boost::noncopyable {
         return _tintBorderFills;
     }
 
+    bool imageButtonTextPulses() const override {
+        return _imageButtonTextPulses;
+    }
+
     float pulsingAlpha() const override {
         return _pulsingAlpha.value();
     }
@@ -297,6 +309,7 @@ class GUI : public IGUI, boost::noncopyable {
     ScalingMode _scaling {ScalingMode::Center};
     std::optional<float> _textScale;
     bool _tintBorderFills {false};
+    bool _imageButtonTextPulses {false};
     glm::ivec2 _rootOffset {0};
     glm::ivec2 _controlOffset {0};
     std::shared_ptr<graphics::Texture> _background;
diff --git a/include/reone/gui/guis.h b/include/reone/gui/guis.h
index 0c87fb5a1..c46217596 100644
--- a/include/reone/gui/guis.h
+++ b/include/reone/gui/guis.h
@@ -37,7 +37,7 @@ class IGUIs {
 
     virtual std::shared_ptr<IGUI> get(const std::string &resRef, std::function<void(IGUI &)> preload = nullptr) = 0;
 
-    /** Advances the pulse every GUI shares, once a frame, by real time. */
+    /** Advances the pulse every GUI shares, once a frame, by dt seconds. */
     virtual void updatePulsingAlpha(float dt) = 0;
 };
 
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index ebd243f67..0e6d30719 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -932,12 +932,13 @@ bool Game::consumeTimingDiscontinuity() {
 }
 
 void Game::update(float frameTime) {
-    // Every GUI's pulse runs on real time, whatever the screen.
-    _services.gui.guis.updatePulsingAlpha(frameTime);
     // The death sequence sets how fast the world, its presentation and the
     // fade run this frame. A pending end keeps the death GUI up while its
     // delay lasts, then returns to the main menu once the game is not over.
     updateDeathSequence();
+    // Every GUI's pulse runs through pauses, whatever the screen, and slows
+    // with the world under the sequel's gameover panel.
+    _services.gui.guis.updatePulsingAlpha(frameTime * _deathTimeScale);
     if (_endGamePending) {
         if (_endGameDelay <= 0.0f) {
             if (!_gameOver) {
@@ -2903,11 +2904,6 @@ static constexpr int kHighestHostileReputation = 10;
 static constexpr float kDeathFadeWait = 12.0f;
 static constexpr float kDeathFadeLength = 1.0f;
 static constexpr float kHurriedFadeLength = 0.5f;
-// The first title's slow motion: it reaches kDeathSlowestSpeed after
-// kDeathSlowSeconds of real time, easing logarithmically from full speed.
-static constexpr float kDeathSlowSeconds = 4.0f;
-static constexpr float kDeathSlowestSpeed = 0.2f;
-static constexpr double kDeathSlowSpan = 0.8;
 // The sequel's gameover panel runs the world at a quarter of its speed.
 static constexpr float kDeathPanelTimeScale = 0.25f;
 // The first title's death message.
@@ -3046,7 +3042,6 @@ void Game::setLastPartyMemberTempKilled(const Creature &creature) {
 // holds before fading to black. Only a fallen party in a module's area starts it.
 void Game::runDeathSequence() {
     _gameOver = true;
-    _deathSequenceStarting = true;
     // Every panel closes, a tutorial window about to open included.
     _tutorialPending.reset();
     stopMovement();
@@ -3099,7 +3094,6 @@ void Game::endGame(bool showGui) {
     _endGameDelay = showGui ? (isTSL() ? kEndGameGuiDelayTSL : kEndGameGuiDelayKotOR) : 0.0f;
     if (showGui && !isTSL()) {
         _gameOver = true;
-        _deathSequenceStarting = true;
     }
 }
 
@@ -3118,36 +3112,22 @@ void Game::hurryDeathSequence() {
     _globalFade.request(GlobalFade::Direction::Out, 0.0f, kHurriedFadeLength, glm::vec3 {0.0f});
 }
 
-// The first title slows the world while its game is over, and ends the game
-// once the fade to black has finished or an end was asked for, and the death
-// message of a scripted end has had its time. The sequel's gameover panel
-// slows the world for as long as it is up.
+// The first title ends the game once the fade to black has finished or an end
+// was asked for, and the death message of a scripted end has had its time; its
+// world keeps full speed throughout. The sequel's gameover panel slows the
+// world for as long as it is up.
 void Game::updateDeathSequence() {
     if (isTSL()) {
         _deathTimeScale = _deathDisplay && _deathDisplay->isPresented() ? kDeathPanelTimeScale : 1.0f;
         return;
     }
-    const auto now = static_cast<uint32_t>(_services.system.clock.millis());
-    const uint32_t elapsed = now - _deathSequenceSample;
-    _deathSequenceSample = now;
     if (!_gameOver) {
         return;
     }
-    _deathSequenceSeconds += static_cast<float>(elapsed) / 1000.0f;
-    if (_deathSequenceStarting) {
-        _deathSequenceStarting = false;
-        _deathSlowRate = static_cast<float>(
-            -std::log(static_cast<double>(_deathSequenceSeconds * (1.0f / kDeathSlowSeconds))) / kDeathSlowSpan);
-    }
-    _deathTimeScale = _deathSequenceSeconds > kDeathSlowSeconds
-                          ? kDeathSlowestSpeed
-                          : -std::log(_deathSequenceSeconds * (1.0f / kDeathSlowSeconds)) / _deathSlowRate + kDeathSlowestSpeed;
     if ((_globalFade.fading() && !_endGamePending) || _endGameDelay > 0.0f) {
         return;
     }
-    _deathTimeScale = 1.0f;
     _gameOver = false;
-    _deathSequenceStarting = true;
     _globalFade.stop();
     requestEndGame();
     if (_deathMessage) {
diff --git a/src/libs/game/gui/chargen.cpp b/src/libs/game/gui/chargen.cpp
index dcff53f02..384010f38 100644
--- a/src/libs/game/gui/chargen.cpp
+++ b/src/libs/game/gui/chargen.cpp
@@ -345,11 +345,13 @@ void CharacterGeneration::openSteps() {
 }
 
 void CharacterGeneration::openQuick() {
+    _quick->refreshStep();
     _controls.MODEL_LBL->setVisible(true);
     changeScreen(CharGenScreen::Quick);
 }
 
 void CharacterGeneration::openCustom() {
+    _custom->refreshStep();
     setAttributesVisible(_custom->step() > 1);
     _controls.MODEL_LBL->setVisible(true);
     changeScreen(CharGenScreen::Custom);
@@ -441,6 +443,7 @@ void CharacterGeneration::openNameEntry() {
 
 void CharacterGeneration::openLevelUp() {
     _levelUp->reset();
+    _levelUp->refreshStep();
     _controls.MODEL_LBL->setVisible(true);
     changeScreen(CharGenScreen::LevelUp);
 }
diff --git a/src/libs/game/gui/chargen/abilities.cpp b/src/libs/game/gui/chargen/abilities.cpp
index 31a905e9f..940525860 100644
--- a/src/libs/game/gui/chargen/abilities.cpp
+++ b/src/libs/game/gui/chargen/abilities.cpp
@@ -120,22 +120,22 @@ void CharGenAbilities::onGUILoaded() {
     });
 
     _controls.STR_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Strength, selected);
+        onAbilityLabelSelectionChanged(Ability::Strength, *_controls.STR_LBL, *_controls.STR_POINTS_BTN, selected);
     });
     _controls.DEX_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Dexterity, selected);
+        onAbilityLabelSelectionChanged(Ability::Dexterity, *_controls.DEX_LBL, *_controls.DEX_POINTS_BTN, selected);
     });
     _controls.CON_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Constitution, selected);
+        onAbilityLabelSelectionChanged(Ability::Constitution, *_controls.CON_LBL, *_controls.CON_POINTS_BTN, selected);
     });
     _controls.INT_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Intelligence, selected);
+        onAbilityLabelSelectionChanged(Ability::Intelligence, *_controls.INT_LBL, *_controls.INT_POINTS_BTN, selected);
     });
     _controls.WIS_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Wisdom, selected);
+        onAbilityLabelSelectionChanged(Ability::Wisdom, *_controls.WIS_LBL, *_controls.WIS_POINTS_BTN, selected);
     });
     _controls.CHA_LBL->setOnSelectionChanged([this](bool selected) {
-        onAbilityLabelSelectionChanged(Ability::Charisma, selected);
+        onAbilityLabelSelectionChanged(Ability::Charisma, *_controls.CHA_LBL, *_controls.CHA_POINTS_BTN, selected);
     });
 
     _controls.STR_MINUS_BTN->setOnClick([this]() {
@@ -238,7 +238,10 @@ void CharGenAbilities::updateCharacter() {
     _charGen.setCharacter(std::move(character));
 }
 
-void CharGenAbilities::onAbilityLabelSelectionChanged(Ability ability, bool selected) {
+void CharGenAbilities::onAbilityLabelSelectionChanged(Ability ability, Label &label, Button &points, bool selected) {
+    // The hovered row's name and points pulse.
+    label.setTextPulsing(selected);
+    points.setTextPulsing(selected);
     if (!selected)
         return;
 
diff --git a/src/libs/game/gui/chargen/custom.cpp b/src/libs/game/gui/chargen/custom.cpp
index 028c62e75..7b714ed5c 100644
--- a/src/libs/game/gui/chargen/custom.cpp
+++ b/src/libs/game/gui/chargen/custom.cpp
@@ -129,6 +129,20 @@ void CustomCharacterGeneration::doSetStep(int step) {
     _controls.BTN_STEPNAME4->setSelected(_step == 3);
     _controls.BTN_STEPNAME5->setSelected(_step == 4);
     _controls.BTN_STEPNAME6->setSelected(_step == 5);
+
+    // The current step's number and name pulse.
+    _controls.LBL_NUM1->setTextPulsing(_step == 0);
+    _controls.LBL_NUM2->setTextPulsing(_step == 1);
+    _controls.LBL_NUM3->setTextPulsing(_step == 2);
+    _controls.LBL_NUM4->setTextPulsing(_step == 3);
+    _controls.LBL_NUM5->setTextPulsing(_step == 4);
+    _controls.LBL_NUM6->setTextPulsing(_step == 5);
+    _controls.BTN_STEPNAME1->setTextPulsing(_step == 0);
+    _controls.BTN_STEPNAME2->setTextPulsing(_step == 1);
+    _controls.BTN_STEPNAME3->setTextPulsing(_step == 2);
+    _controls.BTN_STEPNAME4->setTextPulsing(_step == 3);
+    _controls.BTN_STEPNAME5->setTextPulsing(_step == 4);
+    _controls.BTN_STEPNAME6->setTextPulsing(_step == 5);
 }
 
 void CustomCharacterGeneration::goToNextStep() {
diff --git a/src/libs/game/gui/chargen/levelup.cpp b/src/libs/game/gui/chargen/levelup.cpp
index 4ecba1b88..10cb6cb3b 100644
--- a/src/libs/game/gui/chargen/levelup.cpp
+++ b/src/libs/game/gui/chargen/levelup.cpp
@@ -162,6 +162,18 @@ void LevelUpMenu::doSetStep(int step) {
     _controls.BTN_STEPNAME3->setSelected(_step == 2);
     _controls.BTN_STEPNAME4->setSelected(_step == 3);
     _controls.BTN_STEPNAME5->setSelected(_step == 4);
+
+    // The current step's number and name pulse.
+    _controls.LBL_NUM1->setTextPulsing(_step == 0);
+    _controls.LBL_NUM2->setTextPulsing(_step == 1);
+    _controls.LBL_NUM3->setTextPulsing(_step == 2);
+    _controls.LBL_NUM4->setTextPulsing(_step == 3);
+    _controls.LBL_NUM5->setTextPulsing(_step == 4);
+    _controls.BTN_STEPNAME1->setTextPulsing(_step == 0);
+    _controls.BTN_STEPNAME2->setTextPulsing(_step == 1);
+    _controls.BTN_STEPNAME3->setTextPulsing(_step == 2);
+    _controls.BTN_STEPNAME4->setTextPulsing(_step == 3);
+    _controls.BTN_STEPNAME5->setTextPulsing(_step == 4);
 }
 
 bool LevelUpMenu::hasFeatChoices() const {
diff --git a/src/libs/game/gui/chargen/quick.cpp b/src/libs/game/gui/chargen/quick.cpp
index 6dad85bd0..2e3ac49fe 100644
--- a/src/libs/game/gui/chargen/quick.cpp
+++ b/src/libs/game/gui/chargen/quick.cpp
@@ -96,6 +96,14 @@ void QuickCharacterGeneration::doSetStep(int step) {
     _controls.BTN_STEPNAME1->setSelected(_step == 0);
     _controls.BTN_STEPNAME2->setSelected(_step == 1);
     _controls.BTN_STEPNAME3->setSelected(_step == 2);
+
+    // The current step's number and name pulse.
+    _controls.LBL_NUM1->setTextPulsing(_step == 0);
+    _controls.LBL_NUM2->setTextPulsing(_step == 1);
+    _controls.LBL_NUM3->setTextPulsing(_step == 2);
+    _controls.BTN_STEPNAME1->setTextPulsing(_step == 0);
+    _controls.BTN_STEPNAME2->setTextPulsing(_step == 1);
+    _controls.BTN_STEPNAME3->setTextPulsing(_step == 2);
 }
 
 void QuickCharacterGeneration::goToNextStep() {
diff --git a/src/libs/game/gui/chargen/skills.cpp b/src/libs/game/gui/chargen/skills.cpp
index c3367b65e..7085f7aaa 100644
--- a/src/libs/game/gui/chargen/skills.cpp
+++ b/src/libs/game/gui/chargen/skills.cpp
@@ -106,28 +106,28 @@ void CharGenSkills::onGUILoaded() {
     });
 
     _controls.COMPUTER_USE_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::ComputerUse, selected);
+        onSkillLabelSelectionChanged(SkillType::ComputerUse, *_controls.COMPUTER_USE_LBL, *_controls.COMPUTER_USE_POINTS_BTN, selected);
     });
     _controls.DEMOLITIONS_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Demolitions, selected);
+        onSkillLabelSelectionChanged(SkillType::Demolitions, *_controls.DEMOLITIONS_LBL, *_controls.DEMOLITIONS_POINTS_BTN, selected);
     });
     _controls.STEALTH_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Stealth, selected);
+        onSkillLabelSelectionChanged(SkillType::Stealth, *_controls.STEALTH_LBL, *_controls.STEALTH_POINTS_BTN, selected);
     });
     _controls.AWARENESS_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Awareness, selected);
+        onSkillLabelSelectionChanged(SkillType::Awareness, *_controls.AWARENESS_LBL, *_controls.AWARENESS_POINTS_BTN, selected);
     });
     _controls.PERSUADE_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Persuade, selected);
+        onSkillLabelSelectionChanged(SkillType::Persuade, *_controls.PERSUADE_LBL, *_controls.PERSUADE_POINTS_BTN, selected);
     });
     _controls.REPAIR_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Repair, selected);
+        onSkillLabelSelectionChanged(SkillType::Repair, *_controls.REPAIR_LBL, *_controls.REPAIR_POINTS_BTN, selected);
     });
     _controls.SECURITY_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::Security, selected);
+        onSkillLabelSelectionChanged(SkillType::Security, *_controls.SECURITY_LBL, *_controls.SECURITY_POINTS_BTN, selected);
     });
     _controls.TREAT_INJURY_LBL->setOnSelectionChanged([this](bool selected) {
-        onSkillLabelSelectionChanged(SkillType::TreatInjury, selected);
+        onSkillLabelSelectionChanged(SkillType::TreatInjury, *_controls.TREAT_INJURY_LBL, *_controls.TREAT_INJURY_POINTS_BTN, selected);
     });
 
     _controls.COM_MINUS_BTN->setOnClick([this]() {
@@ -274,7 +274,10 @@ void CharGenSkills::onPlusButtonClick(SkillType skill) {
     refreshControls();
 }
 
-void CharGenSkills::onSkillLabelSelectionChanged(SkillType skill, bool selected) {
+void CharGenSkills::onSkillLabelSelectionChanged(SkillType skill, Label &label, Button &points, bool selected) {
+    // The hovered row's name and points pulse.
+    label.setTextPulsing(selected);
+    points.setTextPulsing(selected);
     if (!selected)
         return;
 
diff --git a/src/libs/game/gui/hud.cpp b/src/libs/game/gui/hud.cpp
index 874378265..e29b0088c 100644
--- a/src/libs/game/gui/hud.cpp
+++ b/src/libs/game/gui/hud.cpp
@@ -274,6 +274,7 @@ static void tintHUDMenuButton(const std::shared_ptr<Button> &button, const glm::
 void HUD::preload(IGUI &gui) {
     gui.setResolution(800, 600);
     gui.setScaling(GUI::ScalingMode::PositionRelativeToCenter);
+    gui.setImageButtonTextPulses(isTSL());
 
     static constexpr const char *kCentredCombatControls[] = {
         "BTN_CLEARALL", "BTN_CLEARONE", "BTN_CLEARONE2",
@@ -566,6 +567,9 @@ void HUD::loadPausePanel() {
     _pauseControls.LBL_PRESS = std::static_pointer_cast<Label>(find("LBL_PRESS"));
     // The prompt's authored text takes custom tokens.
     _pauseControls.LBL_PRESS->setTextMessage(_game.substituteCustomTokens(_pauseControls.LBL_PRESS->text().text));
+    // The reason and the prompt pulse.
+    _pauseControls.LBL_PAUSEREASON->setTextPulsing(true);
+    _pauseControls.LBL_PRESS->setTextPulsing(true);
     // A click anywhere on the indicator resumes play.
     _pauseControls.BTN_UNPAUSE->setOnClick([this]() {
         _game.togglePlayerPause();
@@ -1099,7 +1103,7 @@ void HUD::renderMinimap() {
     std::shared_ptr<Area> area(_game.module()->area());
     // The frame is a control and scales with the layout; the map drawn inside
     // it is not, so it has to be told.
-    _game.map().render(Map::Mode::Minimap, bounds, _gui->scale());
+    _game.map().render(Map::Mode::Minimap, bounds, _gui->scale(), _gui->pulsingAlpha());
 }
 
 // Combat-mode lines
@@ -1218,7 +1222,7 @@ void HUD::refreshActionQueueItems() const {
         }
         Label &label = queueLabels[shown].get();
         label.setBorderFill(icon);
-        label.setBorderFillOpacity(shown == 0 && !current ? kIdleActionQueueOpacity : 1.0f);
+        label.setBorderAlpha(shown == 0 && !current ? kIdleActionQueueOpacity : 1.0f);
         label.setVisible(true);
         ++shown;
     };
diff --git a/src/libs/game/gui/ingame/abilities.cpp b/src/libs/game/gui/ingame/abilities.cpp
index ea5f58866..0ce3cedcc 100644
--- a/src/libs/game/gui/ingame/abilities.cpp
+++ b/src/libs/game/gui/ingame/abilities.cpp
@@ -84,11 +84,9 @@ void AbilitiesMenu::onGUILoaded() {
         protoItem.setHilightFill("uibit_fill_2wt");
         protoItem.setTintBorderFill(true);
     }
-    // The active row's frames pulse; TSL's text pulses too, and its icon
-    // frame is white.
+    // The active row's frames pulse; TSL's icon frame is white.
     protoItem.setHilightPulsing(true, false);
     if (_game.isTSL()) {
-        protoItem.setHilightTextPulsing(true);
         protoItem.setIconFrameHilight(glm::vec3 {1.0f}, true);
     } else {
         protoItem.setIconFrameHilight(std::nullopt, true);
diff --git a/src/libs/game/gui/ingame/character.cpp b/src/libs/game/gui/ingame/character.cpp
index cbd0709c5..f6aa7c718 100644
--- a/src/libs/game/gui/ingame/character.cpp
+++ b/src/libs/game/gui/ingame/character.cpp
@@ -132,6 +132,9 @@ void CharacterMenu::onGUILoaded() {
     }
 
     _controls.BTN_AUTO->setDisabled(true);
+    // The level-up buttons' texts pulse until the pointer first leaves them.
+    _controls.BTN_AUTO->setTextPulsing(true);
+    _controls.BTN_LEVELUP->setTextPulsing(true);
     _controls.BTN_EXIT->setOnClick([this]() {
         _game.openInGame();
     });
diff --git a/src/libs/game/gui/ingame/inventory.cpp b/src/libs/game/gui/ingame/inventory.cpp
index a6d1780c7..030746ef8 100644
--- a/src/libs/game/gui/ingame/inventory.cpp
+++ b/src/libs/game/gui/ingame/inventory.cpp
@@ -127,9 +127,6 @@ void InventoryMenu::onGUILoaded() {
             if (_onExit) _onExit();
         });
     }
-    if (_controls.BTN_ALL) {
-        _controls.BTN_ALL->setSelected(true);
-    }
 
     configureItemsListBox();
     configureFilterControls();
diff --git a/src/libs/game/gui/ingame/map.cpp b/src/libs/game/gui/ingame/map.cpp
index 38bc3b128..4ec221978 100644
--- a/src/libs/game/gui/ingame/map.cpp
+++ b/src/libs/game/gui/ingame/map.cpp
@@ -86,7 +86,7 @@ void MapMenu::render() {
         extent.width,
         extent.height);
 
-    _game.map().render(Map::Mode::Default, bounds, _gui->scale());
+    _game.map().render(Map::Mode::Default, bounds, _gui->scale(), _gui->pulsingAlpha());
 }
 
 void MapMenu::refreshControls() {
diff --git a/src/libs/game/gui/map.cpp b/src/libs/game/gui/map.cpp
index db9ad2249..6644c787b 100644
--- a/src/libs/game/gui/map.cpp
+++ b/src/libs/game/gui/map.cpp
@@ -82,14 +82,14 @@ void Map::loadTextures(const std::string &area) {
     }
 }
 
-void Map::render(Mode mode, const glm::vec4 &bounds, float scale) {
+void Map::render(Mode mode, const glm::vec4 &bounds, float scale, float pulsingAlpha) {
     if (!_areaTexture) {
         return;
     }
-    _services.graphics.context.withBlendMode(BlendMode::Normal, [this, &mode, &bounds, scale]() {
+    _services.graphics.context.withBlendMode(BlendMode::Normal, [this, &mode, &bounds, scale, pulsingAlpha]() {
         renderArea(mode, bounds, scale);
         renderNotes(mode, bounds, scale);
-        renderPartyLeader(mode, bounds, scale);
+        renderPartyLeader(mode, bounds, scale, pulsingAlpha);
     });
 }
 
@@ -220,7 +220,7 @@ glm::vec2 Map::getMapPosition(const glm::vec2 &world) const {
     return result;
 }
 
-void Map::renderPartyLeader(Mode mode, const glm::vec4 &bounds, float scale) {
+void Map::renderPartyLeader(Mode mode, const glm::vec4 &bounds, float scale, float pulsingAlpha) {
     std::shared_ptr<Creature> partyLeader(_game.party().getLeader());
     if (!partyLeader) {
         return;
@@ -264,9 +264,12 @@ void Map::renderPartyLeader(Mode mode, const glm::vec4 &bounds, float scale) {
     transform = glm::translate(transform, glm::vec3(-0.5f * arrowSize, -0.5f * arrowSize, 0.0f));
     transform = glm::scale(transform, glm::vec3(arrowSize, arrowSize, 1.0f));
 
-    _services.graphics.uniforms.setLocals([this, transform](auto &locals) {
+    // On the map screen the arrow pulses; on the minimap it is steady.
+    const float alpha = mode == Mode::Default ? pulsingAlpha : 1.0f;
+    _services.graphics.uniforms.setLocals([this, transform, alpha](auto &locals) {
         locals.reset();
         locals.model = std::move(transform);
+        locals.color.a = alpha;
     });
     _services.graphics.context.useProgram(_services.graphics.shaderRegistry.get(ShaderProgramId::mvpIcon));
     _services.graphics.meshRegistry.get(MeshName::quad).draw(_services.graphics.statistic);
diff --git a/src/libs/game/gui/saveload.cpp b/src/libs/game/gui/saveload.cpp
index 745a696fc..0d6394b4a 100644
--- a/src/libs/game/gui/saveload.cpp
+++ b/src/libs/game/gui/saveload.cpp
@@ -178,6 +178,7 @@ void SaveLoad::onGUILoaded() {
     _saveNameGUI = _services.gui.guis.get(guiResRef("savename"), [this](IGUI &gui) {
         gui.setResolution(_game.isTSL() ? 800 : 640, _game.isTSL() ? 600 : 480);
         gui.setScaling(GUI::ScalingMode::Center);
+        gui.setImageButtonTextPulses(_game.isTSL());
     });
     if (_saveNameGUI) {
         _saveNameControls.BTN_CANCEL = std::static_pointer_cast<Button>(_saveNameGUI->findControl("BTN_CANCEL"));
diff --git a/src/libs/game/presentationgui.cpp b/src/libs/game/presentationgui.cpp
index 76c989320..075e5f0df 100644
--- a/src/libs/game/presentationgui.cpp
+++ b/src/libs/game/presentationgui.cpp
@@ -82,6 +82,7 @@ void PresentationGUI::preload(IGUI &gui) {
         // values carry the screen palette; drawing the textures white turns
         // title bars and panels into opaque gray rectangles.
         gui.setTintBorderFills(true);
+        gui.setImageButtonTextPulses(true);
     } else {
         gui.setDefaultHilightColor(kGUIColorHilight);
     }
@@ -375,7 +376,8 @@ void PresentationGUI::updateK2FilterButton(const std::shared_ptr<Control> &butto
         return;
     }
 
-    button->setSelected(selected);
+    // The chosen filter is told apart by its text colour alone; it is not
+    // selected, so its text pulses only while hovered, as any button's.
     button->setTextColor(selected ? glm::vec3 {1.0f} : _baseColor);
 }
 
diff --git a/src/libs/gui/control.cpp b/src/libs/gui/control.cpp
index b8c1e3e58..6245933f6 100644
--- a/src/libs/gui/control.cpp
+++ b/src/libs/gui/control.cpp
@@ -76,6 +76,12 @@ void Control::load(const resource::generated::GUI_BASECONTROL &gui, bool protoIt
     loadExtent(gui.EXTENT);
     loadBorder(gui.BORDER);
     _tintBorderFill = _gui.tintBorderFills();
+    _isProtoItem = protoItem;
+    // A button's text pulses while the button is selected, and so does an
+    // image button's where the GUI says so.
+    _text.hilightPulsing = _type == ControlType::Button ||
+                           _type == ControlType::ToggleButton ||
+                           (_type == ControlType::ImageButton && _gui.imageButtonTextPulses());
 
     if (static_cast<ControlType>(gui.CONTROLTYPE) == ControlType::Panel) {
         _id = -1;
@@ -300,7 +306,7 @@ void Control::renderBorder(const Border &border,
                 *border.fill,
                 {_extent.left + leftWidth + offset.x, _extent.top + topHeight + offset.y},
                 fillSize,
-                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), _borderFillOpacity * fillAlpha),
+                glm::vec4(_tintBorderFill ? color : glm::vec3(1.0f), fillAlpha),
                 uv,
                 _sharpenBorderFillAlpha ? ImageAlphaMode::Sharpen : ImageAlphaMode::Default);
         });
@@ -576,6 +582,13 @@ void Control::setSelected(bool setSelected) {
 
     _selected = setSelected;
 
+    // Deselecting a control whose text pulses while selected stops the text's
+    // pulse. A list's prototype is selected and deselected for each row it
+    // draws, so it keeps its text's pulse.
+    if (!setSelected && _text.hilightPulsing && !_isProtoItem) {
+        _text.pulsing = false;
+    }
+
     if (_onSelectedChanged) {
         _onSelectedChanged(setSelected);
     }
@@ -661,7 +674,7 @@ void Control::setHilightColor(glm::vec3 color) {
 
 void Control::setHilightPulsing(bool frame, bool fill) {
     if (!_hilight) {
-        _hilight = std::make_shared<Border>();
+        return;
     }
     _hilight->pulseFrame = frame;
     _hilight->pulseFill = fill;
diff --git a/src/libs/gui/control/progressbar.cpp b/src/libs/gui/control/progressbar.cpp
index d116d0b1b..7f7362c06 100644
--- a/src/libs/gui/control/progressbar.cpp
+++ b/src/libs/gui/control/progressbar.cpp
@@ -42,8 +42,7 @@ void ProgressBar::load(const resource::generated::GUI_BASECONTROL &gui, bool pro
     auto &controlStruct = *static_cast<const resource::generated::GUI_CONTROLS *>(&gui);
     _startFromLeft = controlStruct.STARTFROMLEFT != 0;
     if (controlStruct.PROGRESS) {
-        _progress.fill = _resourceSvc.textures.get(controlStruct.PROGRESS->FILL, TextureUsage::GUI);
-        _progress.color = controlStruct.PROGRESS->COLOR;
+        _progress = createBorder(*controlStruct.PROGRESS);
     }
 }
 
@@ -57,9 +56,10 @@ void ProgressBar::render(const glm::ivec2 &screenSize,
     // colour - draws at full size behind the cropped fill, so a partially
     // filled bar keeps its full silhouette.
     Control::render(screenSize, offset, pass);
-    if (_value == 0 || !_progress.fill) {
+    if (_value == 0 || !_progress || !_progress->fill) {
         return;
     }
+    const glm::vec4 color {_progress->color, _progress->pulseFill ? _gui.pulsingAlpha() : _progress->alpha};
     // The fill fraction follows the bar's long axis, keeping the full
     // authored size on the cross axis, and crops the art to the visible
     // fraction instead of squashing it. Tall bars - the party vitality and
@@ -74,10 +74,10 @@ void ProgressBar::render(const glm::ivec2 &screenSize,
         uv[1][1] = fraction;
         uv[2][1] = 0.0f;
         pass.drawImage(
-            *_progress.fill,
+            *_progress->fill,
             {_extent.left + offset.x, top},
             {_extent.width, bottom - top},
-            glm::vec4(_progress.color, 1.0f),
+            color,
             uv);
     } else {
         int left = _extent.left + offset.x;
@@ -91,10 +91,10 @@ void ProgressBar::render(const glm::ivec2 &screenSize,
         uv[0][0] = fraction;
         uv[2][0] = _startFromLeft ? 0.0f : 1.0f - fraction;
         pass.drawImage(
-            *_progress.fill,
+            *_progress->fill,
             {fillLeft, _extent.top + offset.y},
             {fillRight - fillLeft, _extent.height},
-            glm::vec4(_progress.color, 1.0f),
+            color,
             uv);
     }
 }
diff --git a/test/fixtures/gui.h b/test/fixtures/gui.h
index b50e25f72..d4cc2911a 100644
--- a/test/fixtures/gui.h
+++ b/test/fixtures/gui.h
@@ -49,6 +49,7 @@ class MockGUI : public IGUI, boost::noncopyable {
     MOCK_METHOD(float, borderScale, (), (const override));
     float listScale() const override { return 1.0f; }
     MOCK_METHOD(bool, tintBorderFills, (), (const override));
+    MOCK_METHOD(bool, imageButtonTextPulses, (), (const override));
     MOCK_METHOD(float, pulsingAlpha, (), (const override));
     bool sceneRenderEnabled() const override { return true; }
 
@@ -57,6 +58,7 @@ class MockGUI : public IGUI, boost::noncopyable {
     MOCK_METHOD(void, setScaling, (ScalingMode), (override));
     MOCK_METHOD(void, setTextScale, (float), (override));
     MOCK_METHOD(void, setTintBorderFills, (bool), (override));
+    MOCK_METHOD(void, setImageButtonTextPulses, (bool), (override));
     MOCK_METHOD(void, setControlScaling, (const std::string &, ScalingMode), (override));
     MOCK_METHOD(void, setDefaultHilightColor, (glm::vec3), (override));
     MOCK_METHOD(void, setBackground, (std::shared_ptr<graphics::Texture>), (override));

From 5b539dfcb58da236e473f58410e6cf738d477a85 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 16:32:01 -0400
Subject: [PATCH 07/23] - Keyboard skip: FIXED. Return and keypad Enter skip
 the shown entry and,   with the replies listed, choose the selected reply
 (the first row as   they are listed) with the click sound; a left button
 press skips. Both   panels and the computer camera shot, both titles. The
 camera overlay   has no input of its own any more (no LBL_RETURN click, no
 Escape).   The gamepad accept event stays with the deferred gamepad row. -
 TSL alien voices: FIXED. TSL nodes take their sound from emotion.2da   and
 alienvo.2da by AlienRaceNode/AlienRaceOwner and Emotion, never from   the
 Sound field; such a sound is voiced and plays with a variation   number drawn
 per conversation from a walk seeded by the dialog's name   (one-liners take 1
 to 3 at random). - A skip during pause: FIXED. A skip is asked for paused or
 not, and the   next update that runs the conversation honours it if the entry
 can be   skipped then; every skip goes through this path.

---
 include/reone/game/game.h                 |   5 +
 include/reone/game/gui/computer.h         |   4 +-
 include/reone/game/gui/computercam.h      |   8 +-
 include/reone/game/gui/conversation.h     |  76 +++++-
 include/reone/game/gui/dialog.h           |   1 +
 include/reone/game/presentationpointer.h  |   3 +
 include/reone/gui/control/listbox.h       |  11 +
 include/reone/input/event.h               |   1 +
 include/reone/resource/dialog.h           |  17 ++
 include/reone/resource/provider/dialogs.h |  43 +++-
 src/libs/game/gui/computer.cpp            |  19 +-
 src/libs/game/gui/computercam.cpp         |  21 +-
 src/libs/game/gui/conversation.cpp        | 286 ++++++++++++++++------
 src/libs/game/gui/dialog.cpp              |  13 +-
 src/libs/game/presentationpointer.cpp     |   1 +
 src/libs/gui/control/listbox.cpp          |  18 +-
 src/libs/resource/di/module.cpp           |   2 +-
 src/libs/resource/provider/dialogs.cpp    |  73 +++++-
 test/game/computer.cpp                    |  32 +--
 test/game/conversation.cpp                |   1 +
 test/resource/provider/dialogs.cpp        |   7 +-
 21 files changed, 496 insertions(+), 146 deletions(-)

diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 9e23e3e61..0196bd75d 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -631,6 +631,11 @@ class Game : boost::noncopyable {
         return _pointer->type();
     }
 
+    /** Where the pointer last moved to, in screen coordinates. */
+    glm::ivec2 pointerPosition() const {
+        return _pointer->position();
+    }
+
     bool relativeMouseMode() const;
 
     // Module loading
diff --git a/include/reone/game/gui/computer.h b/include/reone/game/gui/computer.h
index 581b21cc6..36b6c5c81 100644
--- a/include/reone/game/gui/computer.h
+++ b/include/reone/game/gui/computer.h
@@ -32,7 +32,7 @@ class ComputerGUI : public Conversation {
 public:
     ComputerGUI(Game &game, ServicesView &services) :
         Conversation(game, services),
-        _cameraGUI(game, services, [this]() { returnFromCamera(); }) {
+        _cameraGUI(game, services) {
         _resRef = guiResRef("computer");
     }
 
@@ -64,7 +64,6 @@ class ComputerGUI : public Conversation {
     /** KotOR: the computer type the panel was last framed for, which numbers the backdrop. */
     int _computerType {0};
 
-    void returnFromCamera();
     /** Switches between the panel and a camera shot; the terminal hum starts when the panel shows. */
     void setPresentation(Presentation presentation);
     /** Starts the terminal hum from its beginning. */
@@ -150,6 +149,7 @@ class ComputerGUI : public Conversation {
 
     void setMessage(std::string message) override;
     void setReplyLines(std::vector<std::string> lines) override;
+    std::shared_ptr<gui::ListBox> replyList() const override;
 };
 
 } // namespace game
diff --git a/include/reone/game/gui/computercam.h b/include/reone/game/gui/computercam.h
index 7611f88c1..827fa4893 100644
--- a/include/reone/game/gui/computercam.h
+++ b/include/reone/game/gui/computercam.h
@@ -18,15 +18,11 @@ namespace game {
 // Transparent presentation only; the owning computer conversation drives it.
 class ComputerCamGUI : public GameGUI {
 public:
-    ComputerCamGUI(Game &game, ServicesView &services, std::function<void()> onReturn);
-
-    bool handle(const input::Event &event) override;
+    /** The overlay of a computer conversation's camera shot; it has no input of its own. */
+    ComputerCamGUI(Game &game, ServicesView &services);
 
 private:
-    std::function<void()> _onReturn;
-
     void preload(gui::IGUI &gui) override;
-    void onGUILoaded() override;
 };
 
 } // namespace game
diff --git a/include/reone/game/gui/conversation.h b/include/reone/game/gui/conversation.h
index c59abed86..204381543 100644
--- a/include/reone/game/gui/conversation.h
+++ b/include/reone/game/gui/conversation.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <array>
 #include <map>
 
 #include "reone/audio/source.h"
@@ -33,6 +34,12 @@
 
 namespace reone {
 
+namespace gui {
+
+class ListBox;
+
+}
+
 namespace game {
 
 class Conversation : public GameGUI {
@@ -116,8 +123,30 @@ class Conversation : public GameGUI {
 
     // Complete the active entry's presentation using the same path as expiry.
     void endCurrentEntry();
-    /** Skips the current entry, when it can be skipped: its voice stops and it ends now. */
-    void skipCurrentEntry();
+    /**
+     * Asks to skip the shown entry, paused or not. The next update that runs
+     * the conversation honours it, if the entry can be skipped then.
+     */
+    void requestSkip();
+    /**
+     * Whether a press asks for a skip: while the entry shows, and while a
+     * reply taken without a choice holds the next entry back.
+     */
+    bool acceptsSkip() const;
+    /** As the replies are listed, selects the row under the pointer, if any. */
+    void selectReplyUnderPointer();
+
+    /**
+     * The conversation's own input: a left button press or Return or keypad
+     * Enter asks to skip the shown entry. With the replies listed, Return or
+     * keypad Enter chooses the selected reply, a number key the reply of its
+     * number, and the up and down arrows move the selection.
+     *
+     * @return whether \p event was used up
+     */
+    bool handleConversationInput(const input::Event &event);
+    /** The list the replies are listed in; none in a presentation without one. */
+    virtual std::shared_ptr<gui::ListBox> replyList() const;
 
     /** One line per reply, in reply order; an empty line stands for a reply that is not listed. */
     virtual void setReplyLines(std::vector<std::string> lines) = 0;
@@ -165,7 +194,7 @@ class Conversation : public GameGUI {
     int _waitFlags {0};
     /** The entry that follows a reply taken without a choice, once the reply's delay and waits are over. */
     std::optional<int> _pendingEntry;
-    /** The current entry was skipped: it ends without waiting. */
+    /** A skip of the shown entry has been asked for and not yet honoured. */
     bool _entrySkipped {false};
     EntryFade _entryFade;
     std::vector<const resource::Dialog::EntryReply *> _replies;
@@ -178,12 +207,28 @@ class Conversation : public GameGUI {
     /** The objects this conversation has made its participants. */
     std::vector<RuntimeObjectRef<Object>> _dialogParticipants;
 
+    /**
+     * A walk through a cycle of values, which starts where the dialog's name
+     * puts it and moves by a step in one direction.
+     */
+    struct DrawCycle {
+        static constexpr int kLength = 19;
+        using Values = std::array<int, kLength>;
+
+        int place {0};
+        int step {1};
+        bool forward {false};
+
+        /** Starts the walk where \p seed puts it. */
+        void seed(uint32_t seed);
+        /** The value at the walk's place in \p values; the walk then moves on. */
+        int draw(const Values &values);
+    };
+
     // Camera shots
 
-    /** The place in the cycle of camera angles, and the step and direction it moves by. */
-    int _angleCyclePlace {0};
-    int _angleCycleStep {1};
-    bool _angleCycleForward {false};
+    /** The walk through the cycle of camera angles. */
+    DrawCycle _angleCycle;
     /** No entry, or no list of replies, has been given a camera angle yet. */
     bool _firstEntryShot {true};
     bool _firstReplyShot {true};
@@ -200,13 +245,18 @@ class Conversation : public GameGUI {
     /** The view is an animated shot, until another shot is taken. */
     bool _animatedView {false};
 
-    /** Starts the cycle of camera angles where the dialog's name puts it. */
+    /** Starts the cycles of camera angles and sound variations where the dialog's name puts them. */
     void seedCameraAngles();
     /** The next angle of the cycle, for an entry or reply without one. */
     int drawCameraAngle();
 
     // END Camera shots
 
+    /** The walk through the cycle of sound variation numbers. */
+    DrawCycle _soundVariationCycle;
+    /** The sounds of the entries by index that took a variation number, once shown. */
+    std::map<int, std::string> _entrySounds;
+
     /** Make \p object a participant of this conversation, unless another conversation still holds it. */
     void attachDialogParticipant(const std::shared_ptr<Object> &object);
     /** Release the participants that \p owner's conversation still holds. */
@@ -218,7 +268,8 @@ class Conversation : public GameGUI {
 
     void loadCameraModel();
     void loadStartEntry();
-    void loadVoiceOver();
+    /** Plays the current entry's voice: \p sound, or else its voice-over. */
+    void loadVoiceOver(const std::string &sound);
     void scheduleEndOfEntry();
     /** Holds the next entry back after \p reply, taken without a choice. */
     void scheduleTakenReply(const resource::Dialog::EntryReply &reply);
@@ -271,7 +322,12 @@ class Conversation : public GameGUI {
     // Event handlers
 
     bool handleMouseButtonDown(const input::MouseButtonEvent &event);
-    bool handleKeyUp(const input::KeyEvent &event);
+    /** Return, keypad Enter, the arrows and the number keys, on their press. */
+    bool handleKeyDown(const input::KeyEvent &event);
+    /** Chooses the reply the reply list has selected, if it has one. */
+    void pickSelectedReply();
+    /** Moves the reply list's selection by \p step rows. */
+    void moveReplySelection(int step);
 
     // END Event handlers
 };
diff --git a/include/reone/game/gui/dialog.h b/include/reone/game/gui/dialog.h
index 0305c2592..a9e648722 100644
--- a/include/reone/game/gui/dialog.h
+++ b/include/reone/game/gui/dialog.h
@@ -210,6 +210,7 @@ class DialogGUI : public Conversation {
 
     void setMessage(std::string message) override;
     void setReplyLines(std::vector<std::string> lines) override;
+    std::shared_ptr<gui::ListBox> replyList() const override;
 
     void onStart() override;
     void onFinish() override;
diff --git a/include/reone/game/presentationpointer.h b/include/reone/game/presentationpointer.h
index 5db9042ec..1ab202dcf 100644
--- a/include/reone/game/presentationpointer.h
+++ b/include/reone/game/presentationpointer.h
@@ -35,6 +35,8 @@ class PresentationPointer {
     void setType(resource::CursorType type);
     resource::CursorType type() const { return _type; }
     void setPosition(glm::ivec2 position);
+    /** Where the pointer last moved to, in screen coordinates. */
+    glm::ivec2 position() const { return _position; }
     void setPressed(bool pressed);
     void render(const graphics::GraphicsOptions &options, bool relativeMouseMode);
 
@@ -42,6 +44,7 @@ class PresentationPointer {
     resource::ICursors &_cursors;
     resource::CursorType _type {resource::CursorType::None};
     std::shared_ptr<graphics::Cursor> _cursor;
+    glm::ivec2 _position {0};
 };
 
 /** Existing cursor decision for an already selected object; performs no picking. */
diff --git a/include/reone/gui/control/listbox.h b/include/reone/gui/control/listbox.h
index aa295d323..b37f9db1f 100644
--- a/include/reone/gui/control/listbox.h
+++ b/include/reone/gui/control/listbox.h
@@ -84,6 +84,11 @@ class ListBox : public Control {
     void setExtent(Extent extent) override;
     void setExtentHeight(int height) override;
     void setSelectionMode(SelectionMode mode);
+    /**
+     * Whether a hovered list keeps its selected row when the pointer is over
+     * no row or leaves the list, rather than losing it.
+     */
+    void setKeepsSelection(bool keeps) { _keepsSelection = keeps; }
     void setSelectedItemIndex(int index);
     void setItemsInteractive(bool interactive);
     void setScrollBarEnabled(bool enabled);
@@ -103,6 +108,11 @@ class ListBox : public Control {
     void setTextLineRows(bool lines);
     void setRenderItemIconsForButtonProto(bool render);
     void scrollToBottom();
+    /**
+     * Scroll the least that brings row \p index into view: up to it when it
+     * is above the visible rows, or down until it is the last visible row.
+     */
+    void scrollToItem(int index);
 
     /**
      * Draws underneath the list's own frame and rows. Lets a GUI repaint
@@ -168,6 +178,7 @@ class ListBox : public Control {
 
 private:
     SelectionMode _selectionMode {SelectionMode::OnHover};
+    bool _keepsSelection {false};
     std::shared_ptr<Control> _protoItem;
     std::shared_ptr<Control> _scrollBar;
     std::vector<Item> _items;
diff --git a/include/reone/input/event.h b/include/reone/input/event.h
index 5f55de4b1..31b379913 100644
--- a/include/reone/input/event.h
+++ b/include/reone/input/event.h
@@ -119,6 +119,7 @@ enum class KeyCode {
     Delete = '\x7F',
     End = 77 | (1 << 30),
     PageDown = 78 | (1 << 30),
+    KeypadEnter = 88 | (1 << 30),
     Right = 79 | (1 << 30),
     Left = 80 | (1 << 30),
     Down = 81 | (1 << 30),
diff --git a/include/reone/resource/dialog.h b/include/reone/resource/dialog.h
index 1b6a28a94..e6ee9f380 100644
--- a/include/reone/resource/dialog.h
+++ b/include/reone/resource/dialog.h
@@ -72,6 +72,8 @@ struct Dialog {
 
         std::string speaker;
         std::string text;
+        /** The talk table string of the node's text, or -1 for none. */
+        int textStrRef {-1};
         std::string voResRef;
         std::string script;
         std::string script2;
@@ -88,6 +90,21 @@ struct Dialog {
         int waitFlags {0};
         /** The node's sound is a recorded voice, which times the node by the dialog's entry delay. */
         bool soundExists {false};
+        /**
+         * TSL: the node's sound, or else its voice-over, takes a variation
+         * number added to its name, as alien speech does.
+         */
+        bool soundTakesVariation {false};
+        /**
+         * TSL: the node is authored as having its variation number already:
+         * a shown entry adds none, though a barked one-liner still does.
+         */
+        bool soundVariationAdded {false};
+        /**
+         * The node is spoken by its voice-over alone: with subtitles off, the
+         * cinematic panel does not show its text.
+         */
+        bool voiceOverOnly {false};
         /** TSL: the entry cannot be skipped, even in a skippable conversation. */
         bool nodeUnskippable {false};
         /** How the entry fades the screen: 0 not at all; 1 and 4 towards the colour, others away from it. */
diff --git a/include/reone/resource/provider/dialogs.h b/include/reone/resource/provider/dialogs.h
index de964cba2..ab15878c8 100644
--- a/include/reone/resource/provider/dialogs.h
+++ b/include/reone/resource/provider/dialogs.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <optional>
+
 #include "../dialog.h"
 #include "../parser/gff/dlg.h"
 
@@ -27,6 +29,8 @@ namespace resource {
 class Gffs;
 class Gff;
 class Strings;
+class TwoDA;
+class TwoDAs;
 
 class IDialogs {
 public:
@@ -39,9 +43,15 @@ class IDialogs {
 
 class Dialogs : public IDialogs {
 public:
-    Dialogs(Gffs &gffs, Strings &strings) :
+    /**
+     * @param twoDas the tables TSL's alien speech is looked up in
+     * @param game the title the dialogs are read for
+     */
+    Dialogs(Gffs &gffs, Strings &strings, TwoDAs &twoDas, GameID game) :
         _gffs(gffs),
-        _strings(strings) {
+        _strings(strings),
+        _twoDas(twoDas),
+        _game(game) {
     }
 
     void clear() override {
@@ -58,17 +68,44 @@ class Dialogs : public IDialogs {
     }
 
 private:
+    /** TSL: the tables alien speech is looked up in. */
+    struct AlienSpeechTables {
+        std::shared_ptr<TwoDA> emotions;
+        std::shared_ptr<TwoDA> voices;
+    };
+
+    /** TSL: the tables a node's alien speech is looked up in, and the race of the dialog's owner. */
+    struct AlienSpeech {
+        AlienSpeechTables tables;
+        int ownerRace {0};
+    };
+
     Gffs &_gffs;
     Strings &_strings;
+    TwoDAs &_twoDas;
+    GameID _game;
+    /** TSL: the alien speech tables, read with the first dialog. */
+    std::optional<AlienSpeechTables> _alienSpeechTables;
 
     std::unordered_map<std::string, std::shared_ptr<Dialog>> _objects;
 
     std::shared_ptr<Dialog> doGet(std::string resRef);
 
     std::unique_ptr<Dialog> loadDialog(const generated::DLG &dlg);
+    /** TSL: the alien speech tables, read once. */
+    const AlienSpeechTables &alienSpeechTables();
 
     Dialog::EntryReplyLink getEntryReplyLink(const generated::DLG_EntryReplyList_EntriesRepliesList &dlg) const;
-    Dialog::EntryReply getEntryReply(const generated::DLG_EntryReplyList &dlg) const;
+    /**
+     * @param alienSpeech TSL: where the node's sound is looked up; KotOR
+     *        reads the node's own Sound field instead
+     */
+    Dialog::EntryReply getEntryReply(const generated::DLG_EntryReplyList &dlg, const std::optional<AlienSpeech> &alienSpeech) const;
+    /**
+     * TSL: the alien speech of \p dlg, from the alien voice table's row for
+     * its race and the column its emotion names; empty when there is none.
+     */
+    std::string getAlienSpeech(const generated::DLG_EntryReplyList &dlg, const AlienSpeech &alienSpeech) const;
     Dialog::Stunt getStunt(const generated::DLG_StuntList &dlg) const;
     Dialog::ParticipantAnimation getParticipantAnimation(const generated::DLG_EntryReplyList_AnimList &dlg) const;
 };
diff --git a/src/libs/game/gui/computer.cpp b/src/libs/game/gui/computer.cpp
index e9d2fd563..fdce4ca82 100644
--- a/src/libs/game/gui/computer.cpp
+++ b/src/libs/game/gui/computer.cpp
@@ -51,9 +51,11 @@ void ComputerGUI::init() {
     _cameraGUI.init();
 }
 
+// A camera shot takes the conversation's own input, its skip, as the panel
+// does; the camera overlay sees the input first.
 bool ComputerGUI::handle(const input::Event &event) {
     if (_presentation == Presentation::Camera) {
-        return _cameraGUI.handle(event);
+        return _cameraGUI.handle(event) || handleConversationInput(event);
     }
     return Conversation::handle(event);
 }
@@ -96,13 +98,6 @@ void ComputerGUI::onEntryEnded() {
     setPresentation(Presentation::Normal);
 }
 
-void ComputerGUI::returnFromCamera() {
-    // Returning from a camera shot skips the entry.
-    if (_presentation == Presentation::Camera) {
-        skipCurrentEntry();
-    }
-}
-
 void ComputerGUI::setPresentation(Presentation presentation) {
     if (presentation == _presentation) {
         return;
@@ -149,6 +144,8 @@ void ComputerGUI::configureMessage() {
 
 void ComputerGUI::configureReplies() {
     _controls.LB_REPLIES->setProtoMatchContent(true);
+    // The selected reply stays selected when the pointer moves off it.
+    _controls.LB_REPLIES->setKeepsSelection(true);
     _controls.LB_REPLIES->protoItem().setHilightColor(_hilightColor);
     _controls.LB_REPLIES->protoItem().setTextColor(_baseColor);
     _controls.LB_REPLIES->setOnItemClick([this](auto &item) {
@@ -234,11 +231,17 @@ void ComputerGUI::setReplyLines(std::vector<std::string> lines) {
         item.text = lines[i];
         _controls.LB_REPLIES->addItem(std::move(item));
     }
+    // The first reply is selected as the replies are listed.
+    _controls.LB_REPLIES->setSelectedItemIndex(0);
     // The numbers are written when an entry's message is set and again when
     // its replies are listed, as the entry ends.
     refreshSkills();
 }
 
+std::shared_ptr<ListBox> ComputerGUI::replyList() const {
+    return _controls.LB_REPLIES;
+}
+
 } // namespace game
 
 } // namespace reone
diff --git a/src/libs/game/gui/computercam.cpp b/src/libs/game/gui/computercam.cpp
index 9ff97d610..0f4c62a33 100644
--- a/src/libs/game/gui/computercam.cpp
+++ b/src/libs/game/gui/computercam.cpp
@@ -10,15 +10,13 @@
 #include "reone/game/gui/computercam.h"
 
 #include "reone/game/game.h"
-#include "reone/gui/control/label.h"
 
 namespace reone {
 
 namespace game {
 
-ComputerCamGUI::ComputerCamGUI(Game &game, ServicesView &services, std::function<void()> onReturn) :
-    GameGUI(game, services),
-    _onReturn(std::move(onReturn)) {
+ComputerCamGUI::ComputerCamGUI(Game &game, ServicesView &services) :
+    GameGUI(game, services) {
     _resRef = game.isTSL() ? guiResRef("computercam") : "computercamera";
 }
 
@@ -28,21 +26,6 @@ void ComputerCamGUI::preload(gui::IGUI &gui) {
     gui.setResolution(640, 480);
 }
 
-void ComputerCamGUI::onGUILoaded() {
-    auto returnControl = findControl<gui::Label>("LBL_RETURN");
-    returnControl->setSelectable(true);
-    returnControl->setOnClick(_onReturn);
-}
-
-bool ComputerCamGUI::handle(const input::Event &event) {
-    if (event.type == input::EventType::KeyUp &&
-        (event.key.code == input::KeyCode::Escape || event.key.code == input::KeyCode::Return)) {
-        _onReturn();
-        return true;
-    }
-    return GameGUI::handle(event);
-}
-
 } // namespace game
 
 } // namespace reone
diff --git a/src/libs/game/gui/conversation.cpp b/src/libs/game/gui/conversation.cpp
index f488a7b3a..f46fbe874 100644
--- a/src/libs/game/gui/conversation.cpp
+++ b/src/libs/game/gui/conversation.cpp
@@ -26,6 +26,7 @@
 #include "reone/audio/mixer.h"
 #include "reone/game/di/services.h"
 #include "reone/game/game.h"
+#include "reone/game/gui/sounds.h"
 #include "reone/game/object/area.h"
 #include "reone/game/object/creature.h"
 #include "reone/game/object/placeable.h"
@@ -37,7 +38,10 @@
 #include "reone/resource/provider/lips.h"
 #include "reone/resource/provider/models.h"
 #include "reone/resource/resources.h"
+#include "reone/resource/resref.h"
+#include "reone/resource/strings.h"
 #include "reone/system/logutil.h"
+#include "reone/system/randomutil.h"
 
 using namespace reone::audio;
 
@@ -67,6 +71,10 @@ static constexpr int kSecurityCameraVideoEffect = 0;
 // the first entry and the first list of replies without one.
 static constexpr std::array<int, 19> kCameraAngleCycle {1, 3, 1, 3, 2, 2, 1, 3, 1, 2, 1, 2, 1, 3, 2, 3, 1, 1, 1};
 static constexpr int kFirstShotCameraAngle = 2;
+// The variation numbers the entries whose sound takes one draw in turn, and
+// the highest number a barked one-liner's sound takes at random.
+static constexpr std::array<int, 19> kSoundVariationCycle {1, 1, 2, 3, 1, 2, 1, 2, 2, 3, 3, 3, 1, 3, 2, 1, 3, 2, 2};
+static constexpr int kBarkSoundVariations = 3;
 
 static bool g_allEntriesSkippable = false;
 
@@ -390,6 +398,13 @@ void Conversation::cleanupForModuleTransition() {
     }
 }
 
+// The sound a variation number is added to: the node's sound, or else its
+// voice-over.
+static std::string getVariedSound(const Dialog::EntryReply &node, int variation) {
+    const std::string &sound = node.sound.empty() ? node.voResRef : node.sound;
+    return ResRef(sound + std::to_string(variation)).value();
+}
+
 void Conversation::loadEntry(int index, bool start) {
     auto generation = _generation;
     auto dialog = _dialog; // retain nodes across callbacks, including conditions
@@ -397,6 +412,9 @@ void Conversation::loadEntry(int index, bool start) {
     _currentEntry = &_dialog->getEntry(index);
     // An entry keeps the camera angle it is given while the conversation lasts.
     const int drawnAngle = drawCameraAngle();
+    // Each entry shown draws a sound variation number; only TSL marks a sound
+    // to take one.
+    const int drawnSoundVariation = _soundVariationCycle.draw(kSoundVariationCycle);
     int &angle = _entryCameraAngles.try_emplace(index, _currentEntry->cameraAngle).first->second;
     if (angle == 0) {
         angle = _firstEntryShot ? kFirstShotCameraAngle : drawnAngle;
@@ -440,7 +458,15 @@ void Conversation::loadEntry(int index, bool start) {
         // update timer from ending it again.
         _endReached = true;
         // The bark keeps its voice: the conversation ending does not stop it.
-        loadVoiceOver();
+        // A sound that takes a variation number takes one at random. A line
+        // with neither a sound nor a voice-over plays its talk table sound.
+        std::string barkSound = _currentEntry->soundTakesVariation
+                                    ? getVariedSound(*_currentEntry, randomInt(1, kBarkSoundVariations))
+                                    : _currentEntry->sound;
+        if (barkSound.empty() && _currentEntry->voResRef.empty()) {
+            barkSound = _services.resource.strings.getSound(_currentEntry->textStrRef);
+        }
+        loadVoiceOver(barkSound);
         _currentVoice.reset();
         _game.globalFade().revealDialog(_fadeDialog);
         _entryEnded = true;
@@ -478,7 +504,13 @@ void Conversation::loadEntry(int index, bool start) {
     // journal entry and plot experience follow.
     setMessage(entryText);
     logEntryLine(entryText);
-    loadVoiceOver();
+    // An entry whose sound takes a variation number keeps the number drawn
+    // the first time it shows while the conversation lasts.
+    std::string sound = _currentEntry->sound;
+    if (_currentEntry->soundTakesVariation && !_currentEntry->soundVariationAdded) {
+        sound = _entrySounds.try_emplace(index, getVariedSound(*_currentEntry, drawnSoundVariation)).first->second;
+    }
+    loadVoiceOver(sound);
     scheduleEndOfEntry();
     if (isAnimatedCameraShot()) {
         _animatedView = true;
@@ -511,8 +543,8 @@ void Conversation::loadEntry(int index, bool start) {
 
     if (_autoSkip) {
         if (std::optional<bool> skip = _autoSkip->trySkipEntry()) {
-            if (skip.value() && !_paused) {
-                skipCurrentEntry();
+            if (skip.value()) {
+                requestSkip();
             }
         }
     }
@@ -582,10 +614,10 @@ void Conversation::takeCameraShot(const Dialog::EntryReply &shot, int angle) {
 
 // Each character of the dialog's name weighs itself plus itself times ten to
 // the power of its place, in 32-bit arithmetic; a power beyond 32 bits weighs
-// as the least 32-bit integer. The sum gives the place, step and direction.
+// as the least 32-bit integer. The sum starts the cycles of camera angles and
+// sound variation numbers alike.
 void Conversation::seedCameraAngles() {
     static constexpr double kFirstOutOfRangePower = 2147483648.0;
-    static constexpr uint32_t kStepCount = 5;
     uint32_t seed = 0;
     const std::string &name = _dialog->resRef;
     for (size_t place = 0; place < name.size(); ++place) {
@@ -594,28 +626,40 @@ void Conversation::seedCameraAngles() {
         const int32_t scale = power < kFirstOutOfRangePower ? static_cast<int32_t>(power) : std::numeric_limits<int32_t>::min();
         seed += weight + weight * static_cast<uint32_t>(scale);
     }
-    _angleCyclePlace = static_cast<int>(seed % kCameraAngleCycle.size());
-    _angleCycleStep = static_cast<int>(seed % kStepCount) + 1;
-    _angleCycleForward = (seed & 1) != 0;
+    _angleCycle.seed(seed);
+    _soundVariationCycle.seed(seed);
     _firstEntryShot = true;
     _firstReplyShot = true;
     _entryCameraAngles.clear();
     _replyCameraAngles.clear();
+    _entrySounds.clear();
 }
 
-// A step past either end of the cycle stops at the other end.
 int Conversation::drawCameraAngle() {
-    const int last = static_cast<int>(kCameraAngleCycle.size()) - 1;
-    const int angle = kCameraAngleCycle[_angleCyclePlace];
-    int next = _angleCyclePlace + (_angleCycleForward ? _angleCycleStep : -_angleCycleStep);
+    return _angleCycle.draw(kCameraAngleCycle);
+}
+
+// The seed gives the place, a step of 1 to 5 and the direction.
+void Conversation::DrawCycle::seed(uint32_t seed) {
+    static constexpr uint32_t kStepCount = 5;
+    place = static_cast<int>(seed % kLength);
+    step = static_cast<int>(seed % kStepCount) + 1;
+    forward = (seed & 1) != 0;
+}
+
+// A step past either end of the cycle stops at the other end.
+int Conversation::DrawCycle::draw(const Values &values) {
+    const int last = kLength - 1;
+    const int value = values[place];
+    int next = place + (forward ? step : -step);
     if (next > last) {
         next = 0;
     }
     if (next < 0) {
         next = last;
     }
-    _angleCyclePlace = next;
-    return angle;
+    place = next;
+    return value;
 }
 
 bool Conversation::isAnimatedCameraShot() const {
@@ -636,18 +680,18 @@ std::optional<std::reference_wrapper<const Dialog::EntryReply>> Conversation::fi
 
 // An entry with a sound stops the voice before it; one without leaves it
 // playing.
-void Conversation::loadVoiceOver() {
+void Conversation::loadVoiceOver(const std::string &sound) {
     _lipAnimation.reset();
-    if (_currentEntry->sound.empty() && _currentEntry->voResRef.empty()) {
+    if (sound.empty() && _currentEntry->voResRef.empty()) {
         return;
     }
     stopVoice();
 
     // Play current voice over either from Sound or from VO_ResRef
     std::string voiceResRef;
-    if (!_currentEntry->sound.empty()) {
-        voiceResRef = _currentEntry->sound;
-        _lipAnimation = _services.resource.lips.get(_currentEntry->sound);
+    if (!sound.empty()) {
+        voiceResRef = sound;
+        _lipAnimation = _services.resource.lips.get(sound);
     }
     if (!_currentEntry->voResRef.empty()) {
         if (voiceResRef.empty()) {
@@ -941,6 +985,7 @@ void Conversation::pickReply(int index) {
     applyStatusSummaryEntries(reply);
     const bool taken = _autoPickFirstReply;
     if (taken) {
+        setMessage(getParsedReplyText(reply, _game));
         startEntryFade(reply);
         onReplyTaken(reply);
         scheduleTakenReply(reply);
@@ -973,33 +1018,141 @@ void Conversation::pickReply(int index) {
 }
 
 bool Conversation::handle(const input::Event &event) {
+    if (handleConversationInput(event)) {
+        return true;
+    }
+    return GameGUI::handle(event);
+}
+
+bool Conversation::handleConversationInput(const input::Event &event) {
     switch (event.type) {
     case input::EventType::MouseButtonDown:
-        if (handleMouseButtonDown(event.button))
-            return true;
-        break;
-    case input::EventType::KeyUp:
-        if (handleKeyUp(event.key))
-            return true;
-        break;
+        return handleMouseButtonDown(event.button);
+    case input::EventType::KeyDown:
+        return handleKeyDown(event.key);
     default:
-        break;
+        return false;
     }
-
-    return GameGUI::handle(event);
 }
 
+// The press is used up, so that its release cannot choose a reply listed
+// meanwhile.
 bool Conversation::handleMouseButtonDown(const input::MouseButtonEvent &event) {
-    // Skipping an entry ends its delay and stops its voice.
-    if (event.button == input::MouseButton::Left && !_entryEnded && isSkippableEntry()) {
-        _endEntryTimer.reset(0);
-        _entrySkipped = true;
-        stopVoice();
+    if (event.button == input::MouseButton::Left && acceptsSkip()) {
+        requestSkip();
         return true;
     }
     return false;
 }
 
+// The keys act once per press. A number key chooses the reply of its number,
+// with the click sound, when there is one.
+bool Conversation::handleKeyDown(const input::KeyEvent &event) {
+    if (event.repeat) {
+        return false;
+    }
+    switch (event.code) {
+    case input::KeyCode::Return:
+    case input::KeyCode::KeypadEnter:
+        if (acceptsSkip()) {
+            requestSkip();
+        } else {
+            pickSelectedReply();
+        }
+        return true;
+    case input::KeyCode::Up:
+    case input::KeyCode::Down:
+        if (!_entryEnded) {
+            return false;
+        }
+        moveReplySelection(event.code == input::KeyCode::Down ? 1 : -1);
+        return true;
+    default:
+        break;
+    }
+
+    using IntKeyCode = std::underlying_type_t<input::KeyCode>;
+    const auto code = static_cast<IntKeyCode>(event.code);
+    const auto key1 = static_cast<IntKeyCode>(input::KeyCode::Key1);
+    const auto key9 = static_cast<IntKeyCode>(input::KeyCode::Key9);
+    if (!_entryEnded || code < key1 || code > key9) {
+        return false;
+    }
+    const auto index = static_cast<size_t>(code - key1);
+    if (index < _replies.size()) {
+        _services.audio.mixer.play(_services.game.guiSounds.getOnClick(), AudioType::Sound);
+        pickReply(static_cast<int>(index));
+    }
+    return true;
+}
+
+std::shared_ptr<ListBox> Conversation::replyList() const {
+    return nullptr;
+}
+
+// The selected row's reply is chosen with the click sound.
+void Conversation::pickSelectedReply() {
+    const auto list = replyList();
+    if (!list || list->selectedItemIndex() == -1) {
+        return;
+    }
+    _services.audio.mixer.play(_services.game.guiSounds.getOnClick(), AudioType::Sound);
+    pickReply(std::stoi(list->getItemAt(list->selectedItemIndex()).tag));
+}
+
+// The selection stops at either end of the list, which scrolls to show it,
+// and the newly selected row sounds. With no row selected, either arrow
+// selects the first row, and only the down arrow sounds.
+void Conversation::moveReplySelection(int step) {
+    const auto list = replyList();
+    if (!list || list->getItemCount() == 0) {
+        return;
+    }
+    const int row = list->selectedItemIndex();
+    int next = 0;
+    bool sounds = step > 0;
+    if (row != -1) {
+        next = row + step;
+        if (next < 0 || next >= list->getItemCount()) {
+            return;
+        }
+        sounds = true;
+    }
+    list->setSelectedItemIndex(next);
+    list->scrollToItem(next);
+    if (sounds) {
+        _services.audio.mixer.play(_services.game.guiSounds.getOnEnter(), AudioType::Sound);
+    }
+}
+
+void Conversation::requestSkip() {
+    if (!acceptsSkip()) {
+        return;
+    }
+    _entrySkipped = true;
+}
+
+// While a reply taken without a choice holds the next entry back, the panel
+// shows the reply's own empty text as its message, as for an entry.
+bool Conversation::acceptsSkip() const {
+    return !_entryEnded || (_autoPickFirstReply && _pendingEntry);
+}
+
+// The row under a resting pointer is selected, with the sound of a newly
+// selected row.
+void Conversation::selectReplyUnderPointer() {
+    const auto list = replyList();
+    if (!list) {
+        return;
+    }
+    const int selected = list->selectedItemIndex();
+    const glm::ivec2 pointer = _game.pointerPosition();
+    _gui->handle(input::Event::newMouseMotion({pointer.x, pointer.y, 0.0f, 0.0f}));
+    if (list->selectedItemIndex() != selected) {
+        _services.audio.mixer.play(_services.game.guiSounds.getOnEnter(), AudioType::Sound);
+    }
+}
+
 // A skip takes effect only in a skippable conversation and, in TSL, on an
 // entry not marked unskippable.
 bool Conversation::isSkippableEntry() const {
@@ -1007,7 +1160,7 @@ bool Conversation::isSkippableEntry() const {
         return true;
     }
     const bool nodeUnskippable = _game.isTSL() && _currentEntry && _currentEntry->nodeUnskippable;
-    return _dialog->isSkippable() && !nodeUnskippable && !_paused;
+    return _dialog->isSkippable() && !nodeUnskippable;
 }
 
 // An entry shown in the conversation goes to the dialog list under its
@@ -1035,6 +1188,7 @@ void Conversation::endCurrentEntry() {
     }
     auto generation = _generation;
     _entryEnded = true;
+    _entrySkipped = false;
     // An entry ends once its time is up.
     _endEntryTimer.reset(0);
 
@@ -1050,6 +1204,7 @@ void Conversation::endCurrentEntry() {
     if (!isCurrent(generation)) {
         return;
     }
+    selectReplyUnderPointer();
 
     if (_autoPickFirstReply) {
         pickReply(0);
@@ -1063,43 +1218,12 @@ void Conversation::endCurrentEntry() {
     }
 }
 
-void Conversation::skipCurrentEntry() {
-    if (!_currentEntry || _entryEnded || _paused || !isSkippableEntry()) {
-        return;
-    }
-    stopVoice();
-    endCurrentEntry();
-}
-
 void Conversation::onEntryEnded() {
 }
 
 void Conversation::onReplyPicked(const Dialog::EntryReply &) {
 }
 
-bool Conversation::handleKeyUp(const input::KeyEvent &event) {
-    if (!_entryEnded || _pendingEntry) {
-        return false;
-    }
-
-    using IntKeyCode = std::underlying_type_t<input::KeyCode>;
-    auto code = static_cast<IntKeyCode>(event.code);
-    auto key1 = static_cast<IntKeyCode>(input::KeyCode::Key1);
-    auto key9 = static_cast<IntKeyCode>(input::KeyCode::Key9);
-
-    if (code < key1 || code > key9) {
-        return false;
-    }
-
-    size_t index = code - key1;
-    if (index < _replies.size()) {
-        pickReply(index);
-    } else {
-        debug("Invalid reply index: " + std::to_string(index), LogChannel::Conversation);
-    }
-    return true;
-}
-
 void Conversation::update(float dt) {
     if (_dialog && !_owner.empty() && !_owner.resolve()) {
         finish();
@@ -1108,15 +1232,31 @@ void Conversation::update(float dt) {
     GameGUI::update(dt);
     if (!_entryEnded) {
         _endEntryTimer.update(dt);
-        if (!_paused && _endEntryTimer.elapsed() && (_entrySkipped || !isWaiting())) {
-            endCurrentEntry();
+        // A pause holds the entry, and a skip asked for meanwhile, until the
+        // conversation resumes. A skip stops the voice and ends the entry,
+        // whatever it waits for.
+        if (!_paused) {
+            if (_entrySkipped && isSkippableEntry()) {
+                stopVoice();
+                endCurrentEntry();
+            } else if (_endEntryTimer.elapsed() && !isWaiting()) {
+                endCurrentEntry();
+            }
         }
     } else if (_pendingEntry) {
         _endEntryTimer.update(dt);
-        if (!_paused && _endEntryTimer.elapsed() && !isWaiting()) {
-            const int index = *_pendingEntry;
-            _pendingEntry.reset();
-            loadEntry(index);
+        // A skip ends the hold of a reply taken without a choice in the same
+        // way.
+        if (!_paused) {
+            const bool skipped = _entrySkipped && isSkippableEntry();
+            if (skipped || (_endEntryTimer.elapsed() && !isWaiting())) {
+                if (skipped) {
+                    stopVoice();
+                }
+                const int index = *_pendingEntry;
+                _pendingEntry.reset();
+                loadEntry(index);
+            }
         }
     }
 }
diff --git a/src/libs/game/gui/dialog.cpp b/src/libs/game/gui/dialog.cpp
index 4120a4c8d..a6e961ac8 100644
--- a/src/libs/game/gui/dialog.cpp
+++ b/src/libs/game/gui/dialog.cpp
@@ -204,6 +204,8 @@ void DialogGUI::configureReplies() {
             safeArea.height});
     }
     _controls.LB_REPLIES->setProtoMatchContent(true);
+    // The selected reply stays selected when the pointer moves off it.
+    _controls.LB_REPLIES->setKeepsSelection(true);
     _controls.LB_REPLIES->protoItem().setTextFont(_controls.LBL_MESSAGE->text().font);
     _controls.LB_REPLIES->protoItem().setScale(_controls.LBL_MESSAGE->scale());
     _controls.LB_REPLIES->protoItem().setTextAlignment(Control::TextAlign::LeftCenter);
@@ -1071,8 +1073,11 @@ bool DialogGUI::isDialogAnimationPlaying() const {
     return false;
 }
 
+// With subtitles off, the text shows only when no voice-over speaks the entry
+// alone, and never in an animated cutscene.
 void DialogGUI::setMessage(std::string message) {
-    _controls.LBL_MESSAGE->setTextMessage(message);
+    const bool shown = _game.feedbackOptions().subtitles || (!_dialog->isAnimatedCutscene() && !_currentEntry->voiceOverOnly);
+    _controls.LBL_MESSAGE->setTextMessage(shown ? message : "");
 }
 
 void DialogGUI::setReplyLines(std::vector<std::string> lines) {
@@ -1087,6 +1092,8 @@ void DialogGUI::setReplyLines(std::vector<std::string> lines) {
         item.text = lines[i];
         _controls.LB_REPLIES->addItem(std::move(item));
     }
+    // The first reply is selected as the replies are listed.
+    _controls.LB_REPLIES->setSelectedItemIndex(0);
     // Replies start at the top-left of the centred 4:3 safe area within the
     // bottom band, indented past the scroll-bar column by their authored
     // offset so an overflowing list shows its bar beside the prose, not
@@ -1114,6 +1121,10 @@ void DialogGUI::setReplyLines(std::vector<std::string> lines) {
     _controls.LB_REPLIES->protoItem().setExtent(std::move(extent));
 }
 
+std::shared_ptr<ListBox> DialogGUI::replyList() const {
+    return _controls.LB_REPLIES;
+}
+
 // The letterbox is drawn with the conversation, so its fade runs with it.
 void DialogGUI::update(float dt) {
     advanceEntryFade(dt);
diff --git a/src/libs/game/presentationpointer.cpp b/src/libs/game/presentationpointer.cpp
index 84352ffea..e175ee95e 100644
--- a/src/libs/game/presentationpointer.cpp
+++ b/src/libs/game/presentationpointer.cpp
@@ -27,6 +27,7 @@ void PresentationPointer::setType(resource::CursorType type) {
 }
 
 void PresentationPointer::setPosition(glm::ivec2 position) {
+    _position = position;
     if (_cursor)
         _cursor->setPosition(position);
 }
diff --git a/src/libs/gui/control/listbox.cpp b/src/libs/gui/control/listbox.cpp
index 6b8cffdf7..e15cbb294 100644
--- a/src/libs/gui/control/listbox.cpp
+++ b/src/libs/gui/control/listbox.cpp
@@ -116,7 +116,10 @@ void ListBox::load(const resource::generated::GUI_BASECONTROL &gui, bool protoIt
 
 bool ListBox::handleMouseMotion(int x, int y) {
     if (_itemsInteractive && _selectionMode == SelectionMode::OnHover) {
-        _selectedItemIndex = getItemIndex(y);
+        const int index = getItemIndex(y);
+        if (index != -1 || !_keepsSelection) {
+            _selectedItemIndex = index;
+        }
     }
     return false;
 }
@@ -356,7 +359,7 @@ void ListBox::insetScrollBar(Control &scrollBar,
 
 void ListBox::setSelected(bool selected) {
     Control::setSelected(selected);
-    if (!selected && _selectionMode == SelectionMode::OnHover) {
+    if (!selected && _selectionMode == SelectionMode::OnHover && !_keepsSelection) {
         _selectedItemIndex = -1;
     }
 }
@@ -524,6 +527,17 @@ void ListBox::setItemOffset(int offset) {
     }
 }
 
+void ListBox::scrollToItem(int index) {
+    if (index < _itemOffset) {
+        _itemOffset = index;
+    }
+    updateItemSlots();
+    while (index >= _itemOffset + _slotCount && _itemOffset < index) {
+        ++_itemOffset;
+        updateItemSlots();
+    }
+}
+
 void ListBox::scrollToBottom() {
     if (!_protoItem || _items.empty()) {
         _itemOffset = 0;
diff --git a/src/libs/resource/di/module.cpp b/src/libs/resource/di/module.cpp
index 4dff0ae75..78ba05728 100644
--- a/src/libs/resource/di/module.cpp
+++ b/src/libs/resource/di/module.cpp
@@ -73,7 +73,7 @@ void ResourceModule::init() {
     _audioClips = std::make_unique<AudioClips>(*_resources, *_auxResources);
     _movies = std::make_unique<Movies>(_gamePath, _graphics.services(), _audio.mixer());
     _scripts = std::make_unique<Scripts>(*_resources, *_replacements);
-    _dialogs = std::make_unique<Dialogs>(*_gffs, *_strings);
+    _dialogs = std::make_unique<Dialogs>(*_gffs, *_strings, *_twoDas, _gameId);
     _layouts = std::make_unique<Layouts>(*_resources);
     _paths = std::make_unique<Paths>(*_gffs);
     _soundSets = std::make_unique<SoundSets>(*_audioClips, *_resources, *_strings);
diff --git a/src/libs/resource/provider/dialogs.cpp b/src/libs/resource/provider/dialogs.cpp
index e9de28154..af7cbd386 100644
--- a/src/libs/resource/provider/dialogs.cpp
+++ b/src/libs/resource/provider/dialogs.cpp
@@ -17,13 +17,26 @@
 
 #include "reone/resource/provider/dialogs.h"
 
+#include "reone/resource/2da.h"
+#include "reone/resource/provider/2das.h"
 #include "reone/resource/provider/gffs.h"
+#include "reone/resource/resref.h"
 #include "reone/resource/strings.h"
 
 namespace reone {
 
 namespace resource {
 
+static constexpr char kEmotionsResRef[] = "emotion";
+static constexpr char kAlienVoicesResRef[] = "alienvo";
+static constexpr char kEmotionLabelColumn[] = "label";
+
+// SoundExists: 1 the node's sound is a recorded voice; 2 (TSL) it takes a
+// variation number; 4 (TSL) the number has been added.
+static constexpr int kSoundIsVoice = 1;
+static constexpr int kSoundTakesVariation = 2;
+static constexpr int kSoundVariationAdded = 4;
+
 std::shared_ptr<Dialog> Dialogs::doGet(std::string resRef) {
     auto dlg = _gffs.get(resRef, ResType::Dlg);
     if (!dlg) {
@@ -48,11 +61,15 @@ std::unique_ptr<Dialog> Dialogs::loadDialog(const resource::generated::DLG &dlg)
     dialog->conversationType = static_cast<ConversationType>(dlg.ConversationType);
     dialog->computerType = static_cast<ComputerType>(dlg.ComputerType);
 
+    std::optional<AlienSpeech> alienSpeech;
+    if (_game == GameID::TSL) {
+        alienSpeech = AlienSpeech {alienSpeechTables(), dlg.AlienRaceOwner};
+    }
     for (auto &entry : dlg.EntryList) {
-        dialog->entries.push_back(getEntryReply(entry));
+        dialog->entries.push_back(getEntryReply(entry, alienSpeech));
     }
     for (auto &reply : dlg.ReplyList) {
-        dialog->replies.push_back(getEntryReply(reply));
+        dialog->replies.push_back(getEntryReply(reply, alienSpeech));
     }
     for (auto &entry : dlg.StartingList) {
         dialog->startEntries.push_back(getEntryReplyLink(entry));
@@ -64,6 +81,14 @@ std::unique_ptr<Dialog> Dialogs::loadDialog(const resource::generated::DLG &dlg)
     return dialog;
 }
 
+// A table the game data lacks finds nothing.
+const Dialogs::AlienSpeechTables &Dialogs::alienSpeechTables() {
+    if (!_alienSpeechTables) {
+        _alienSpeechTables = AlienSpeechTables {_twoDas.get(kEmotionsResRef), _twoDas.get(kAlienVoicesResRef)};
+    }
+    return *_alienSpeechTables;
+}
+
 Dialog::EntryReplyLink Dialogs::getEntryReplyLink(const resource::generated::DLG_EntryReplyList_EntriesRepliesList &dlg) const {
     Dialog::EntryReplyLink link;
     link.index = dlg.Index;
@@ -81,16 +106,16 @@ Dialog::EntryReplyLink Dialogs::getEntryReplyLink(const resource::generated::DLG
     return link;
 }
 
-Dialog::EntryReply Dialogs::getEntryReply(const resource::generated::DLG_EntryReplyList &dlg) const {
+Dialog::EntryReply Dialogs::getEntryReply(const resource::generated::DLG_EntryReplyList &dlg, const std::optional<AlienSpeech> &alienSpeech) const {
     int strRef = dlg.Text.first;
 
     Dialog::EntryReply entry;
     entry.speaker = dlg.Speaker;
     entry.text = strRef == -1 ? "" : _strings.getText(strRef);
+    entry.textStrRef = strRef;
     entry.voResRef = dlg.VO_ResRef;
     entry.script = dlg.Script;
     entry.script2 = dlg.Script2;
-    entry.sound = dlg.Sound;
     entry.listener = dlg.Listener;
     entry.quest = dlg.Quest;
     entry.questEntry = dlg.QuestEntry;
@@ -102,7 +127,26 @@ Dialog::EntryReply Dialogs::getEntryReply(const resource::generated::DLG_EntryRe
     entry.actionParams2.str = dlg.ActionParamStrB;
     entry.delay = dlg.Delay;
     entry.waitFlags = dlg.WaitFlags;
-    entry.soundExists = (dlg.SoundExists & 1) != 0;
+    // KotOR plays the node's Sound field. TSL reads no Sound field: a node's
+    // sound is its alien speech, which is a recorded voice and takes a
+    // variation number. Without a sound, the voice-over plays; with neither,
+    // the node has no recorded voice.
+    int soundExists = dlg.SoundExists;
+    if (alienSpeech) {
+        entry.sound = getAlienSpeech(dlg, *alienSpeech);
+        if (!entry.sound.empty()) {
+            soundExists |= kSoundIsVoice | kSoundTakesVariation;
+        }
+    } else {
+        entry.sound = dlg.Sound;
+    }
+    if (entry.sound.empty() && entry.voResRef.empty()) {
+        soundExists = 0;
+    }
+    entry.soundExists = (soundExists & kSoundIsVoice) != 0;
+    entry.soundTakesVariation = alienSpeech && (soundExists & kSoundTakesVariation) != 0;
+    entry.soundVariationAdded = alienSpeech && (soundExists & kSoundVariationAdded) != 0;
+    entry.voiceOverOnly = (soundExists & kSoundIsVoice) != 0 && (soundExists & kSoundTakesVariation) == 0 && entry.sound.empty();
     entry.nodeUnskippable = dlg.NodeUnskippable != 0;
     // Fade types 1 and 2 cut at once.
     static constexpr int kFirstCutFade = 1;
@@ -135,6 +179,25 @@ Dialog::EntryReply Dialogs::getEntryReply(const resource::generated::DLG_EntryRe
     return entry;
 }
 
+// The race is the node's own; a node with no speaker, which the owner speaks,
+// otherwise takes the owner's. A race of 0 or less has no alien speech, and
+// neither has an emotion or race the tables lack or leave blank.
+std::string Dialogs::getAlienSpeech(const resource::generated::DLG_EntryReplyList &dlg, const AlienSpeech &alienSpeech) const {
+    int race = dlg.AlienRaceNode;
+    if (race <= 0 && dlg.Speaker.empty()) {
+        race = alienSpeech.ownerRace;
+    }
+    const AlienSpeechTables &tables = alienSpeech.tables;
+    if (race <= 0 || !tables.emotions || !tables.voices) {
+        return "";
+    }
+    const std::string emotion = tables.emotions->getString(dlg.Emotion, kEmotionLabelColumn);
+    if (emotion.empty()) {
+        return "";
+    }
+    return ResRef(tables.voices->getString(race, emotion)).value();
+}
+
 Dialog::Stunt Dialogs::getStunt(const resource::generated::DLG_StuntList &dlg) const {
     Dialog::Stunt stunt;
     stunt.participant = boost::to_lower_copy(dlg.Participant);
diff --git a/test/game/computer.cpp b/test/game/computer.cpp
index e1d37e596..2b92a996f 100644
--- a/test/game/computer.cpp
+++ b/test/game/computer.cpp
@@ -105,6 +105,10 @@ input::Event key(input::KeyCode code) {
     return input::Event::newKeyUp({false, code, 0, false});
 }
 
+input::Event press(input::KeyCode code) {
+    return input::Event::newKeyDown({true, code, 0, false});
+}
+
 class ComputerGUITest : public TestWithParam<GameID> {
 protected:
     void SetUp() override {
@@ -114,8 +118,6 @@ class ComputerGUITest : public TestWithParam<GameID> {
         normal = std::make_shared<NiceMock<MockGUI>>();
         camera = std::make_shared<NiceMock<MockGUI>>();
         auto &svc = engine.services();
-        returnControl = std::make_shared<Label>(*camera, svc.scene.graphs, svc.graphics, svc.resource);
-        EXPECT_CALL(*camera, findControl("LBL_RETURN")).WillOnce(Return(returnControl));
         EXPECT_CALL(*camera, setBackground(_)).Times(0);
         EXPECT_CALL(engine.guiModule().guis(), get(GetParam() == GameID::KotOR ? "computer" : "computer_p", _))
             .WillOnce(Return(normal));
@@ -153,7 +155,6 @@ class ComputerGUITest : public TestWithParam<GameID> {
     std::unique_ptr<Game> game;
     std::shared_ptr<NiceMock<MockGUI>> normal;
     std::shared_ptr<NiceMock<MockGUI>> camera;
-    std::shared_ptr<Label> returnControl;
     std::shared_ptr<Label> panel;
     std::unique_ptr<TestComputer> computer;
 };
@@ -199,14 +200,13 @@ TEST_P(ComputerGUITest, return_auto_selects_empty_reply_once_without_replaying_s
     EXPECT_CALL(scripts, get("next_entry")).WillOnce(Return(nullptr));
 
     computer->start(dialog, nullptr);
-    EXPECT_TRUE(computer->handle(key(input::KeyCode::Escape)));
+    EXPECT_TRUE(computer->handle(press(input::KeyCode::Return)));
+    computer->update(0.0f);
     EXPECT_EQ(computer->entry(), &dialog->entries[1]);
     EXPECT_EQ(computer->ends, 1);
     EXPECT_EQ(computer->loads, 2);
     expectRender(false);
 
-    // A queued duplicate click on the old camera control cannot advance again.
-    returnControl->handleClick(0, 0, 1);
     computer->update(3.0f);
     EXPECT_EQ(computer->ends, 1);
     EXPECT_EQ(computer->loads, 2);
@@ -217,8 +217,8 @@ TEST_P(ComputerGUITest, return_preserves_entry_and_existing_multiple_replies) {
     computer->start(dialog, nullptr);
     // The replies are listed when the entry ends.
     EXPECT_TRUE(computer->replies.empty());
-    EXPECT_TRUE(returnControl->isSelectable());
-    returnControl->handleClick(0, 0, 1);
+    computer->handle(input::Event::newMouseButtonDown({input::MouseButton::Left, true, 1, 100, 100}));
+    computer->update(0.0f);
     EXPECT_EQ(computer->entry(), &dialog->entries[0]);
     EXPECT_EQ(computer->replies.size(), 2u);
     EXPECT_EQ(computer->replyRefreshes, 1);
@@ -227,7 +227,7 @@ TEST_P(ComputerGUITest, return_preserves_entry_and_existing_multiple_replies) {
     expectRender(false);
     computer->update(3.0f);
     EXPECT_EQ(computer->ends, 1);
-    computer->handle(key(input::KeyCode::Key1));
+    computer->handle(press(input::KeyCode::Key1));
     EXPECT_EQ(computer->entry(), &dialog->entries[1]);
     EXPECT_EQ(computer->loads, 2);
 }
@@ -262,12 +262,14 @@ TEST_P(ComputerGUITest, consecutive_camera_entries_keep_the_next_feed_visible) {
     dialog->entries[1].cameraId = 3;
     dialog->entries[1].cameraAngle = 6;
     computer->start(dialog, nullptr);
-    computer->handle(key(input::KeyCode::Return));
+    computer->handle(press(input::KeyCode::Return));
+    computer->update(0.0f);
     EXPECT_EQ(computer->entry(), &dialog->entries[1]);
     EXPECT_EQ(computer->loads, 2);
     EXPECT_EQ(computer->ends, 1);
     expectRender(true);
-    computer->handle(key(input::KeyCode::Return));
+    computer->handle(press(input::KeyCode::Return));
+    computer->update(0.0f);
     EXPECT_EQ(computer->ends, 2);
     EXPECT_EQ(computer->replies.size(), 1u);
     expectRender(false);
@@ -276,7 +278,7 @@ TEST_P(ComputerGUITest, consecutive_camera_entries_keep_the_next_feed_visible) {
 TEST_P(ComputerGUITest, paused_entry_cannot_be_completed_by_return_or_timeout) {
     computer->start(computerDialog(), nullptr);
     computer->pause();
-    computer->handle(key(input::KeyCode::Return));
+    computer->handle(press(input::KeyCode::Return));
     computer->update(3.0f);
     expectRender(true);
     EXPECT_EQ(computer->ends, 0);
@@ -295,7 +297,8 @@ TEST_P(ComputerGUITest, finish_without_replies_clears_camera) {
     dialog->entries[0].replies[0].notActive = true;
     computer->start(dialog, nullptr);
     expectRender(true);
-    computer->handle(key(input::KeyCode::Return));
+    computer->handle(press(input::KeyCode::Return));
+    computer->update(0.0f);
     expectRender(false);
     EXPECT_EQ(computer->finishes, 1);
     computer->update(3.0f);
@@ -341,7 +344,8 @@ TEST_P(ComputerGUITest, automatic_reply_script_replacement_preserves_new_convers
             return nullptr;
         }));
     computer->start(dialog, nullptr);
-    computer->handle(key(input::KeyCode::Return));
+    computer->handle(press(input::KeyCode::Return));
+    computer->update(0.0f);
     EXPECT_EQ(computer->entry(), &replacement->entries[0]);
     EXPECT_EQ(computer->loads, 2);
     EXPECT_EQ(computer->ends, 1);
diff --git a/test/game/conversation.cpp b/test/game/conversation.cpp
index e968fd8f2..1b1a3fc1e 100644
--- a/test/game/conversation.cpp
+++ b/test/game/conversation.cpp
@@ -455,6 +455,7 @@ TEST_F(ConversationTest, unpaused_automatic_skip_retains_immediate_progression)
     dialog->skippable = true;
 
     _conversation->start(dialog, nullptr);
+    _conversation->update(0.0f);
 
     EXPECT_EQ("second", _conversation->currentText());
     EXPECT_EQ(2, _conversation->entryLoadCount());
diff --git a/test/resource/provider/dialogs.cpp b/test/resource/provider/dialogs.cpp
index c770413be..7076140d4 100644
--- a/test/resource/provider/dialogs.cpp
+++ b/test/resource/provider/dialogs.cpp
@@ -20,6 +20,7 @@
 #include "reone/resource/container/memory.h"
 #include "reone/resource/format/gffwriter.h"
 #include "reone/resource/gff.h"
+#include "reone/resource/provider/2das.h"
 #include "reone/resource/provider/dialogs.h"
 #include "reone/resource/provider/gffs.h"
 #include "reone/resource/resources.h"
@@ -67,7 +68,8 @@ TEST(Dialogs, should_preserve_quest_and_plot_xp_fields_from_dlg) {
 
     auto gffs = Gffs(resources);
     auto strings = Strings();
-    auto dialogs = Dialogs(gffs, strings);
+    auto twoDas = TwoDAs(resources);
+    auto dialogs = Dialogs(gffs, strings, twoDas, GameID::KotOR);
 
     // when
 
@@ -107,7 +109,8 @@ TEST(Dialogs, should_preserve_resource_identity) {
 
     auto gffs = Gffs(resources);
     auto strings = Strings();
-    auto dialogs = Dialogs(gffs, strings);
+    auto twoDas = TwoDAs(resources);
+    auto dialogs = Dialogs(gffs, strings, twoDas, GameID::KotOR);
 
     // when
 

From a6322ca6b332775d1e02e95ed9c3e72a851dcdcb Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Sat, 24 Oct 2026 17:32:02 -0400
Subject: [PATCH 08/23] Test fix

---
 test/game/object.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/game/object.cpp b/test/game/object.cpp
index b2c6b591e..8e6a49775 100644
--- a/test/game/object.cpp
+++ b/test/game/object.cpp
@@ -1307,9 +1307,11 @@ TEST(Conversation, should_show_script_only_auto_routing_entry_and_advance_at_the
     conversation.start(makeRoutingDialog(), nullptr);
     conversation.update(0.0f);
 
-    ASSERT_EQ(conversation.messages.size(), 2);
+    // The entry's message, the taken reply's own empty text, then the next entry's.
+    ASSERT_EQ(conversation.messages.size(), 3);
     EXPECT_EQ(conversation.messages[0], "");
-    EXPECT_EQ(conversation.messages[1], "visible");
+    EXPECT_EQ(conversation.messages[1], "");
+    EXPECT_EQ(conversation.messages[2], "visible");
     EXPECT_EQ(conversation.presentedEntryCount, 2);
 }
 

From 53b837d417c4f5758805355e9358cea1b9e52704 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:01:41 -0400
Subject: [PATCH 09/23]  A stream that runs out of queued sound now plays on
 from where it ran out at the next refill, unless it was stopped or is paused:
 a source paused for a movie, or created paused, is left for resume().

---
 include/reone/audio/source.h |  7 +++++++
 src/libs/audio/source.cpp    | 16 ++++++++++++++++
 test/fixtures/engine.h       | 34 ++--------------------------------
 3 files changed, 25 insertions(+), 32 deletions(-)

diff --git a/include/reone/audio/source.h b/include/reone/audio/source.h
index 3d0261545..aa3dc8145 100644
--- a/include/reone/audio/source.h
+++ b/include/reone/audio/source.h
@@ -38,6 +38,11 @@ class AudioSource : boost::noncopyable {
     ~AudioSource() { deinit(); }
 
     void init();
+    /**
+     * Refills a stream's queue with the sound that follows. A stream that ran
+     * out of queued sound since the last refill, because the frame came late,
+     * plays on from where it ran out.
+     */
     void render();
 
     void play();
@@ -70,6 +75,8 @@ class AudioSource : boost::noncopyable {
 
     bool _inited {false};
     bool _playing {false};
+    /** Paused, or created paused, and not resumed since. */
+    bool _paused {false};
 
     std::vector<uint32_t> _buffers;
     bool _streaming {false};
diff --git a/src/libs/audio/source.cpp b/src/libs/audio/source.cpp
index c2bd4dea0..7ea8b269e 100644
--- a/src/libs/audio/source.cpp
+++ b/src/libs/audio/source.cpp
@@ -134,6 +134,18 @@ void AudioSource::render() {
     alGetSourcei(_source, AL_BUFFERS_QUEUED, &queued);
     if (queued == 0) {
         _playing = false;
+        return;
+    }
+    // A stream plays on whatever the frame rate: one that ran out of queued
+    // sound before this refill carries on from where it ran out, unless it
+    // was stopped or is paused.
+    if (!_playing || _paused) {
+        return;
+    }
+    ALint state = 0;
+    alGetSourcei(_source, AL_SOURCE_STATE, &state);
+    if (state == AL_STOPPED) {
+        alSourcePlay(_source);
     }
 }
 
@@ -143,10 +155,12 @@ void AudioSource::play() {
     }
     alSourcePlay(_source);
     _playing = true;
+    _paused = false;
 }
 
 void AudioSource::pause() {
     alSourcePause(_source);
+    _paused = true;
 }
 
 // Only a source that is still playing, and paused or created paused, resumes:
@@ -157,6 +171,7 @@ void AudioSource::resume() {
     if (!_playing) {
         return;
     }
+    _paused = false;
     ALint state = 0;
     alGetSourcei(_source, AL_SOURCE_STATE, &state);
     if (state == AL_PAUSED || state == AL_INITIAL) {
@@ -166,6 +181,7 @@ void AudioSource::resume() {
 
 void AudioSource::startPaused() {
     _playing = true;
+    _paused = true;
 }
 
 void AudioSource::stop() {
diff --git a/test/fixtures/engine.h b/test/fixtures/engine.h
index f17acea3e..44e0cef0b 100644
--- a/test/fixtures/engine.h
+++ b/test/fixtures/engine.h
@@ -98,7 +98,7 @@ class TestEngine : boost::noncopyable {
         ON_CALL(_resourceModule->twoDas(), get(std::string("racialtypes"))).WillByDefault(testing::Return(racialTypes));
         _gameModule->races().init(_resourceModule->twoDas());
         // The combat tables the game loads at start, with no rows but an
-        // excitement of no duration and KotOR's experience table.
+        // excitement of no duration.
         testing::NiceMock<resource::MockTwoDAs> combatTables;
         ON_CALL(combatTables, get(testing::_)).WillByDefault(testing::Invoke(&TestEngine::defaultCombatTable));
         _gameModule->combatTables().init(combatTables, resource::GameID::KotOR);
@@ -166,41 +166,11 @@ class TestEngine : boost::noncopyable {
     /** The rows of racialtypes.2da a creature may name. */
     static constexpr int kRacialTypeCount = 9;
 
-    /**
-     * A combat table as the game loads it at start: no rows, but an excitement
-     * of no duration and KotOR's experience table, which also covers the TSL
-     * levels the tests reach.
-     */
+    /** A combat table as the game loads it at start: no rows, but an excitement of no duration. */
     static std::shared_ptr<resource::TwoDA> defaultCombatTable(const std::string &resRef) {
         if (resRef == "excitedduration") {
             return resource::TwoDA::Builder().columns({"duration"}).row({"0"}).row({"0"}).row({"0"}).build();
         }
-        if (resRef == "exptable") {
-            return resource::TwoDA::Builder()
-                .columns({"level", "xp"})
-                .row({"1", "0"})
-                .row({"2", "1000"})
-                .row({"3", "3000"})
-                .row({"4", "6000"})
-                .row({"5", "10000"})
-                .row({"6", "15000"})
-                .row({"7", "21000"})
-                .row({"8", "28000"})
-                .row({"9", "36000"})
-                .row({"10", "45000"})
-                .row({"11", "55000"})
-                .row({"12", "66000"})
-                .row({"13", "78000"})
-                .row({"14", "91000"})
-                .row({"15", "105000"})
-                .row({"16", "120000"})
-                .row({"17", "136000"})
-                .row({"18", "153000"})
-                .row({"19", "171000"})
-                .row({"20", "190000"})
-                .row({"21", "0xFFFFFFFF"})
-                .build();
-        }
         return resource::TwoDA::Builder().build();
     }
 

From 9f0ffcfc94aa90165a7fe9e31f3583245aa884a5 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:02:40 -0400
Subject: [PATCH 10/23] The sound now starts on the movie's first update, with
 its first frame of picture; a movie finished before it is ever updated plays
 no sound.

---
 src/libs/movie/movie.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/libs/movie/movie.cpp b/src/libs/movie/movie.cpp
index 77072965f..93cdde1de 100644
--- a/src/libs/movie/movie.cpp
+++ b/src/libs/movie/movie.cpp
@@ -51,9 +51,6 @@ void Movie::init() {
         _texture->clear(1, 1, PixelFormat::RGB8);
         _texture->init();
     }
-    if (!_audioSource && _audioStream) {
-        _audioSource = _audioPlayer.play(_audioStream, AudioType::Movie);
-    }
     _inited = true;
 }
 
@@ -76,10 +73,15 @@ void Movie::deinit() {
     _inited = false;
 }
 
+// The sound starts with the picture, on the first update, however long the
+// movie waited after it was loaded.
 void Movie::update(float dt) {
     if (!_videoStream || _finished) {
         return;
     }
+    if (!_audioSource && _audioStream) {
+        _audioSource = _audioPlayer.play(_audioStream, AudioType::Movie);
+    }
     _time += dt;
     _videoStream->seek(_time);
     if (_videoStream->hasEnded()) {

From ba1ad972880dd0f4b3b1c3cfdf8c3115c69e9538 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:03:25 -0400
Subject: [PATCH 11/23] Every control is now laid out from the box's corner,
 where the layout authors it, and moved by as much as the box moves.

---
 src/libs/game/gui/confirmpopup.cpp | 49 ++++++++++++++++--------------
 1 file changed, 26 insertions(+), 23 deletions(-)

diff --git a/src/libs/game/gui/confirmpopup.cpp b/src/libs/game/gui/confirmpopup.cpp
index 1467a8e58..14eeb7ea0 100644
--- a/src/libs/game/gui/confirmpopup.cpp
+++ b/src/libs/game/gui/confirmpopup.cpp
@@ -156,20 +156,16 @@ void ConfirmPopup::layoutMessage() {
     const float scale = _gui->scale();
     const auto scaled = [scale](int value) { return static_cast<int>(std::lround(value * scale)); };
 
-    // The box is laid out relative to its top-left corner and centred where
-    // the authored box was centred.
+    // The box and its controls are laid out from the box's top-left corner,
+    // where its controls were authored, and the box is centred where the
+    // authored box was centred.
     int centreX = 0;
     int centreY = 0;
     _rootExtent.getCenter(centreX, centreY);
-    const auto relative = [this](Control::Extent extent) {
-        extent.left -= _rootExtent.left;
-        extent.top -= _rootExtent.top;
-        return extent;
-    };
     Control::Extent panel {0, 0, _rootExtent.width, _rootExtent.height};
-    auto listExtent = relative(_listExtent);
-    auto okExtent = relative(_okExtent);
-    auto cancelExtent = relative(_cancelExtent);
+    auto listExtent = _listExtent;
+    auto okExtent = _okExtent;
+    auto cancelExtent = _cancelExtent;
 
     // An icon makes the box taller and moves the message below it. Without
     // Cancel its row goes.
@@ -214,29 +210,36 @@ void ConfirmPopup::layoutMessage() {
     // Place the box and its message on screen and lay the message out across
     // the list's inner width, less the scroll bar while it is enabled, a line
     // to a row; the message overflows when its lines and the list's padding
-    // are taller than the list inside its border.
-    const auto absolute = [&](Control::Extent extent) {
+    // are taller than the list inside its border. The box's controls are
+    // drawn from the corner the box had when it was loaded, so they move by
+    // as much as the box does.
+    const auto onScreen = [&](Control::Extent extent) {
         extent.left += centreX - panel.width / 2;
         extent.top += centreY - panel.height / 2;
         return extent;
     };
+    const auto inBox = [&](Control::Extent extent) {
+        extent.left += centreX - panel.width / 2 - _rootExtent.left;
+        extent.top += centreY - panel.height / 2 - _rootExtent.top;
+        return extent;
+    };
     const auto wrap = [&]() {
-        root.setExtent(absolute(panel));
-        const auto listOnScreen = absolute(listExtent);
-        list.setExtent(listOnScreen);
+        root.setExtent(onScreen(panel));
+        const auto listInBox = inBox(listExtent);
+        list.setExtent(listInBox);
         if (scrollBar) {
             Control::Extent bar;
-            bar.left = listOnScreen.left + listOnScreen.width - barRightInset - barWidth;
-            bar.top = listOnScreen.top + barTopOffset;
+            bar.left = listInBox.left + listInBox.width - barRightInset - barWidth;
+            bar.top = listInBox.top + barTopOffset;
             bar.width = barWidth;
-            bar.height = listOnScreen.height + barHeightOffset;
+            bar.height = listInBox.height + barHeightOffset;
             scrollBar->setExtent(std::move(bar));
         }
         // The list places the lines itself; the row is a line high and as
         // wide as the room.
         auto textExtent = _messageExtent;
-        textExtent.left = listOnScreen.left;
-        textExtent.top = listOnScreen.top;
+        textExtent.left = listInBox.left;
+        textExtent.top = listInBox.top;
         textExtent.width = std::max(0, list.getItemWidth());
         textExtent.height = lineHeight;
         list.protoItem().setExtent(std::move(textExtent));
@@ -283,13 +286,13 @@ void ConfirmPopup::layoutMessage() {
     Control::Extent iconExtent = _icon->extent();
     iconExtent.left = panel.width / 2 - iconExtent.width / 2;
     iconExtent.top = scaled(kIconTop);
-    _icon->setExtent(absolute(iconExtent));
+    _icon->setExtent(inBox(iconExtent));
     okExtent.top = listExtent.top + listExtent.height + scaled(kOkGap);
     okExtent.left = panel.width / 2 - okExtent.width / 2;
-    ok.setExtent(absolute(okExtent));
+    ok.setExtent(inBox(okExtent));
     cancelExtent.top = okExtent.top + okExtent.height + scaled(kButtonGap);
     cancelExtent.left = panel.width / 2 - cancelExtent.width / 2;
-    cancel.setExtent(absolute(cancelExtent));
+    cancel.setExtent(inBox(cancelExtent));
 }
 
 void ConfirmPopup::showConfirm(

From d1fb5cc476e4064a9afe70435d3cc7aa9a7021cb Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:04:15 -0400
Subject: [PATCH 12/23] the overview showed Equip labelled Close beside the
 back button: two Close buttons. The back button now takes the labels and
 Equip is shown only over a slot's items; its click no longer closes the
 screen.

---
 src/libs/game/gui/ingame/equip.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/libs/game/gui/ingame/equip.cpp b/src/libs/game/gui/ingame/equip.cpp
index 2dc67e154..fe86dbf62 100644
--- a/src/libs/game/gui/ingame/equip.cpp
+++ b/src/libs/game/gui/ingame/equip.cpp
@@ -35,9 +35,9 @@ namespace game {
 
 static constexpr int kStrRefNone = 363;
 static constexpr int kStrRefEquipped = 32346;
-// The Equip button's label over an open slot and over the overview.
-static constexpr int kStrRefEquipButton = 1581;
-static constexpr int kStrRefOverviewButton = 1582;
+// The back button's labels: Cancel over an open slot's items, Close over the overview.
+static constexpr int kStrRefCancelButton = 1581;
+static constexpr int kStrRefCloseButton = 1582;
 // KotOR titles an open slot's item list.
 static constexpr int kStrRefK1SelectTitle = 38154;
 static constexpr char kNoneItemTag[] = "[none]";
@@ -166,12 +166,9 @@ void Equipment::onGUILoaded() {
             _backing->switchWeapons();
             update();
         });
+    // The equip button is shown only over an open slot's items.
     _controls.BTN_EQUIP->setOnClick([this]() {
-        if (_selectedSlot == Slot::None) {
-            if (_onExit) _onExit();
-        } else {
-            confirmSelectedCandidate();
-        }
+        confirmSelectedCandidate();
     });
     _controls.BTN_BACK->setOnClick([this]() {
         if (_selectedSlot == Slot::None) {
@@ -438,7 +435,10 @@ void Equipment::selectSlot(Slot slot) {
 
     _controls.LB_DESC->setVisible(!noneSelected);
     _controls.LBL_SLOTNAME->setVisible(noneSelected);
-    _controls.BTN_EQUIP->setTextMessage(interfaceText(noneSelected ? kStrRefOverviewButton : kStrRefEquipButton));
+    // Over the overview the back button closes the screen and is its only
+    // button; over a slot's items it goes back, beside the equip button.
+    _controls.BTN_BACK->setTextMessage(interfaceText(noneSelected ? kStrRefCloseButton : kStrRefCancelButton));
+    _controls.BTN_EQUIP->setVisible(!noneSelected);
     if (!isTSL() && !noneSelected) {
         _controls.LBL_SELECTTITLE->setTextMessage(interfaceText(kStrRefK1SelectTitle));
     }

From d7cea7f1726188682bb4f697af041e35340ca3ec Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:04:41 -0400
Subject: [PATCH 13/23] - The cinematic panel's reply rows are cleared as an
 entry, or the empty   text of a reply taken without a choice, is shown. - A
 reply is taken only by a place below the number listed (20 in   KotOR, 30 in
 TSL): none while an entry shows, none past the last.   The number keys test
 the same count. - A closed conversation keeps no replies.

---
 include/reone/game/gui/conversation.h |  2 ++
 src/libs/game/gui/conversation.cpp    | 20 +++++++++++++++-----
 src/libs/game/gui/dialog.cpp          |  3 +++
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/include/reone/game/gui/conversation.h b/include/reone/game/gui/conversation.h
index 204381543..f3547f672 100644
--- a/include/reone/game/gui/conversation.h
+++ b/include/reone/game/gui/conversation.h
@@ -289,6 +289,8 @@ class Conversation : public GameGUI {
     /** Add the shown entry's \p text to the dialogue log under its speaker's name. */
     void logEntryLine(const std::string &text);
 
+    /** How many of the replies are listed, and so can be taken. */
+    size_t listedReplyCount() const;
     void refreshReplies();
 
     /**
diff --git a/src/libs/game/gui/conversation.cpp b/src/libs/game/gui/conversation.cpp
index f46fbe874..fe59f6be2 100644
--- a/src/libs/game/gui/conversation.cpp
+++ b/src/libs/game/gui/conversation.cpp
@@ -334,6 +334,8 @@ void Conversation::finish(bool runsEndScript, bool aborted) {
     _paused = false;
     _entryEnded = true;
     _pendingEntry.reset();
+    // A closed conversation keeps no replies to take.
+    _replies.clear();
     stopVoice();
     resetEntryFade();
     onFinish();
@@ -389,6 +391,7 @@ void Conversation::cleanupForModuleTransition() {
         return;
     }
     _pendingEntry.reset();
+    _replies.clear();
     stopVoice();
     resetEntryFade();
     _lipAnimation.reset();
@@ -945,13 +948,17 @@ static std::string getReplyText(const Dialog::EntryReply &reply, int index, cons
     return str(boost::format("%d. %s") % (index + 1) % text);
 }
 
-void Conversation::refreshReplies() {
-    // TSL lists up to 30 replies, KotOR up to 20.
+// TSL lists up to 30 replies, KotOR up to 20.
+size_t Conversation::listedReplyCount() const {
     static constexpr size_t kMaxListedRepliesTSL = 30;
     static constexpr size_t kMaxListedRepliesK1 = 20;
+    return std::min(_replies.size(), _game.isTSL() ? kMaxListedRepliesTSL : kMaxListedRepliesK1);
+}
+
+void Conversation::refreshReplies() {
     std::vector<std::string> lines;
     if (!_autoPickFirstReply) {
-        const size_t listed = std::min(_replies.size(), _game.isTSL() ? kMaxListedRepliesTSL : kMaxListedRepliesK1);
+        const size_t listed = listedReplyCount();
         for (size_t i = 0; i < listed; ++i) {
             lines.push_back(getReplyText(*_replies[i], static_cast<int>(i), _game));
         }
@@ -959,9 +966,12 @@ void Conversation::refreshReplies() {
     setReplyLines(std::move(lines));
 }
 
+// A reply is taken by its place among the replies listed: none while an
+// entry shows, none once the conversation has closed, and no place past the
+// last one listed.
 void Conversation::pickReply(int index) {
     // Once a reply is taken, the next entry is on its way.
-    if (_pendingEntry) {
+    if (_pendingEntry || index >= static_cast<int>(listedReplyCount())) {
         return;
     }
     auto generation = _generation;
@@ -1079,7 +1089,7 @@ bool Conversation::handleKeyDown(const input::KeyEvent &event) {
         return false;
     }
     const auto index = static_cast<size_t>(code - key1);
-    if (index < _replies.size()) {
+    if (index < listedReplyCount()) {
         _services.audio.mixer.play(_services.game.guiSounds.getOnClick(), AudioType::Sound);
         pickReply(static_cast<int>(index));
     }
diff --git a/src/libs/game/gui/dialog.cpp b/src/libs/game/gui/dialog.cpp
index a6e961ac8..074d81426 100644
--- a/src/libs/game/gui/dialog.cpp
+++ b/src/libs/game/gui/dialog.cpp
@@ -1078,6 +1078,9 @@ bool DialogGUI::isDialogAnimationPlaying() const {
 void DialogGUI::setMessage(std::string message) {
     const bool shown = _game.feedbackOptions().subtitles || (!_dialog->isAnimatedCutscene() && !_currentEntry->voiceOverOnly);
     _controls.LBL_MESSAGE->setTextMessage(shown ? message : "");
+    // The replies of the entry are listed when it ends; those of the entry
+    // before are gone.
+    _controls.LB_REPLIES->clearItems();
 }
 
 void DialogGUI::setReplyLines(std::vector<std::string> lines) {

From 95ea419a40764914c4258380579c7e22f81cf574 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:06:31 -0400
Subject: [PATCH 14/23] A click ends a movie at once, but only its picture: its
 sound played on to its end over the menu or the game, with the sounds the
 movie had held let go beneath it.

Finishing a movie stops its sound too. A movie that ends by itself
leaves its sound to end on its own, as before.
---
 include/reone/movie/movie.h | 3 ++-
 src/libs/game/game.cpp      | 3 ++-
 src/libs/movie/movie.cpp    | 8 ++++++++
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/include/reone/movie/movie.h b/include/reone/movie/movie.h
index 8688e94ab..f634377f9 100644
--- a/include/reone/movie/movie.h
+++ b/include/reone/movie/movie.h
@@ -68,7 +68,8 @@ class Movie : public IMovie, boost::noncopyable {
     void update(float dt) override;
     void render() override;
 
-    void finish() override { _finished = true; }
+    /** Ends the movie at once, its sound with its picture. */
+    void finish() override;
 
     bool isFinished() const override { return _finished; }
 
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 0e6d30719..794a0142b 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -615,7 +615,8 @@ void Game::init() {
     _moduleNames = _services.resource.director.moduleNames();
     _saveNames = _services.resource.director.saveNames();
 
-    playVideo("legal");
+    // reone plays no start-up movie: the main menu opens, and its music
+    // starts, at once.
     openMainMenu();
 }
 
diff --git a/src/libs/movie/movie.cpp b/src/libs/movie/movie.cpp
index 93cdde1de..1c12fe115 100644
--- a/src/libs/movie/movie.cpp
+++ b/src/libs/movie/movie.cpp
@@ -89,6 +89,14 @@ void Movie::update(float dt) {
     }
 }
 
+// A movie that has not been updated yet has no sound to stop.
+void Movie::finish() {
+    _finished = true;
+    if (_audioSource) {
+        _audioSource->stop();
+    }
+}
+
 void Movie::render() {
     if (!_videoStream) {
         return;

From 74de1ab46ca2ca748455322478442f32f56212f4 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:22:48 -0400
Subject: [PATCH 15/23]  A movie now switches off the battle music, the pending
 restart and the ambient loop before arrival too, and leaves the music to
 start on arrival.

---
 include/reone/game/areamusicplayer.h |  6 ++++++
 src/libs/game/areamusicplayer.cpp    | 19 +++++++++++++++++++
 src/libs/game/game.cpp               | 11 ++++++-----
 3 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/include/reone/game/areamusicplayer.h b/include/reone/game/areamusicplayer.h
index 13d8797d5..24f1748fb 100644
--- a/include/reone/game/areamusicplayer.h
+++ b/include/reone/game/areamusicplayer.h
@@ -73,6 +73,12 @@ class AreaMusicPlayer : boost::noncopyable {
     void start();
     /** Fade out the music, end the ambient loop and forget the pending restart and battle state. */
     void stopSounds();
+    /**
+     * A movie starts. As stopSounds once the area's sounds have started;
+     * before then the music is left to start on arrival, but the battle
+     * music, the pending restart and the ambient loop are switched off.
+     */
+    void stopSoundsForMovie();
     /** Stop for the area being left; nothing plays until the next area is loaded and started. */
     void unload();
     /** Advance the fades, repeat ended tracks and restart an ended ambient loop. */
diff --git a/src/libs/game/areamusicplayer.cpp b/src/libs/game/areamusicplayer.cpp
index ad12c966a..579b86263 100644
--- a/src/libs/game/areamusicplayer.cpp
+++ b/src/libs/game/areamusicplayer.cpp
@@ -205,6 +205,25 @@ void AreaMusicPlayer::stopSounds() {
     _ambientFailed = false;
 }
 
+// A movie turns the music off only once the area's sounds have started: before
+// that, the music starts on arrival as the area asks. The battle music, the
+// pending restart and the ambient loop are switched off either way, so an area
+// whose enter script plays a movie before arrival has no ambient loop.
+void AreaMusicPlayer::stopSoundsForMovie() {
+    if (_started) {
+        stopSounds();
+        return;
+    }
+    _battleOn = false;
+    _countdown = 0;
+    if (_ambient) {
+        _ambient->stop();
+    }
+    _ambientFadeEnd.reset();
+    _ambientOn = false;
+    _ambientFailed = false;
+}
+
 // Nothing is on once the area is left, so nothing restarts until the next one
 // is loaded; a fading track still fades out.
 void AreaMusicPlayer::unload() {
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 794a0142b..9382fb27c 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -4915,11 +4915,12 @@ bool Game::startVideo(const std::string &name, bool streamingMusic) {
     if (!_movie) {
         return false;
     }
-    // A movie ends the area's music and ambient loop for good. Every other
-    // sound waits for it, including sounds started before it is first shown;
-    // a movie that lets music play leaves area music set to play through
-    // movies sounding while it fades.
-    _areaMusic.stopSounds();
+    // A movie ends the area's music and ambient loop for good; one that
+    // comes before arrival, as an enter script's, leaves the music to start
+    // on arrival but no ambient loop. Every other sound waits for it, including
+    // sounds started before it is first shown; a movie that lets music play
+    // leaves area music set to play through movies sounding while it fades.
+    _areaMusic.stopSoundsForMovie();
     _services.audio.mixer.setSoundsHeldForMovie(true, streamingMusic ? _areaMusic.musicPlayingThroughMovies() : nullptr);
     return true;
 }

From dc0f2981081a263780b0f291625fc8dcad8e6664 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:23:34 -0400
Subject: [PATCH 16/23] A clip whose frames share one format and rate now goes
 into one buffer whole, looping by the source's own flag, so its playback runs
 on the device's clock whatever the main loop does; a clip that changes format
 part-way is still streamed. A source can also be set to loop or not after it
 starts.

---
 include/reone/audio/source.h |  7 ++++
 src/libs/audio/source.cpp    | 63 ++++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)

diff --git a/include/reone/audio/source.h b/include/reone/audio/source.h
index aa3dc8145..4f47bc9a0 100644
--- a/include/reone/audio/source.h
+++ b/include/reone/audio/source.h
@@ -37,6 +37,11 @@ class AudioSource : boost::noncopyable {
 
     ~AudioSource() { deinit(); }
 
+    /**
+     * Prepares the sound. A clip whose frames share one format and rate goes
+     * into one buffer whole and plays on the device's clock; any other clip is
+     * streamed a few frames at a time.
+     */
     void init();
     /**
      * Refills a stream's queue with the sound that follows. A stream that ran
@@ -58,6 +63,8 @@ class AudioSource : boost::noncopyable {
     void startPaused();
 
     void setPosition(glm::vec3 position);
+    /** Sets whether the source starts again from the beginning when it ends. */
+    void setLooping(bool loop);
     /** Scales the gain the source was created with; used to fade it out. */
     void setGainScale(float scale);
     /** Plays the source at \p pitch times its own rate, which raises or lowers its pitch. */
diff --git a/src/libs/audio/source.cpp b/src/libs/audio/source.cpp
index 7ea8b269e..e7595e3f1 100644
--- a/src/libs/audio/source.cpp
+++ b/src/libs/audio/source.cpp
@@ -50,6 +50,42 @@ static void fillBuffer(const AudioClip::Frame &frame, uint32_t buffer) {
         frame.sampleRate);
 }
 
+// A clip whose frames share one format and rate goes into one buffer whole, so
+// its playback runs on the device's clock whatever the frame rate or however
+// long a load holds the main loop; only a clip that changes format part-way is
+// streamed a few frames at a time.
+static bool fillWholeClip(const AudioClip &clip, uint32_t buffer) {
+    int frameCount = clip.getFrameCount();
+    if (frameCount < 2) {
+        return false;
+    }
+    const auto &first = clip.getFrame(0);
+    size_t size = 0;
+    for (int i = 0; i < frameCount; ++i) {
+        const auto &frame = clip.getFrame(i);
+        if (frame.format != first.format || frame.sampleRate != first.sampleRate) {
+            return false;
+        }
+        size += frame.samples.size();
+    }
+    if (size == 0) {
+        return false;
+    }
+    ByteBuffer samples;
+    samples.reserve(size);
+    for (int i = 0; i < frameCount; ++i) {
+        const auto &frame = clip.getFrame(i);
+        samples.insert(samples.end(), frame.samples.begin(), frame.samples.end());
+    }
+    alBufferData(
+        buffer,
+        getALFormat(first.format),
+        samples.data(),
+        static_cast<int>(samples.size()),
+        first.sampleRate);
+    return true;
+}
+
 void AudioSource::init() {
     if (_inited) {
         return;
@@ -57,6 +93,26 @@ void AudioSource::init() {
     checkMainThread();
 
     int frameCount = _stream->getFrameCount();
+    if (frameCount > 1) {
+        uint32_t whole = 0;
+        alGenBuffers(1, &whole);
+        if (fillWholeClip(*_stream, whole)) {
+            _buffers.assign(1, whole);
+            _streaming = false;
+            alGenSources(1, &_source);
+            alSourcef(_source, AL_GAIN, _gain);
+            if (_position) {
+                alSource3f(_source, AL_POSITION, _position->x, _position->y, _position->z);
+            } else {
+                alSourcei(_source, AL_SOURCE_RELATIVE, AL_TRUE);
+            }
+            alSourcei(_source, AL_BUFFER, whole);
+            alSourcei(_source, AL_LOOPING, _loop);
+            _inited = true;
+            return;
+        }
+        alDeleteBuffers(1, &whole);
+    }
     int bufferCount = std::min(std::max(frameCount, 1), kMaxBufferCount);
 
     _buffers.resize(bufferCount);
@@ -206,6 +262,13 @@ void AudioSource::setPosition(glm::vec3 position) {
     _position = std::move(position);
 }
 
+void AudioSource::setLooping(bool loop) {
+    _loop = loop;
+    if (_source && !_streaming) {
+        alSourcei(_source, AL_LOOPING, _loop);
+    }
+}
+
 void AudioSource::setGainScale(float scale) {
     alSourcef(_source, AL_GAIN, _gain * scale);
 }

From b32a3bf75c072cba2a138755419bb43e4cc5a3dd Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:24:00 -0400
Subject: [PATCH 17/23] every loading screen shown with music starts it, and
 the menu music stops. Nothing starts while the load's transition movies are
 listed; music that is there is resumed; else the set track starts, looping,
 in the streamed music group. A movie holds it, as it holds every sound but
 its own.

---
 include/reone/game/areamusicplayer.h         | 19 +++-
 include/reone/game/game.h                    | 24 +++++
 include/reone/game/gui/loadscreen.h          |  6 ++
 include/reone/resource/provider/audioclips.h |  7 ++
 src/libs/game/areamusicplayer.cpp            | 14 ++-
 src/libs/game/game.cpp                       | 94 +++++++++++++++++++-
 src/libs/game/gui/chargen.cpp                | 10 ++-
 src/libs/game/gui/loadscreen.cpp             | 22 +++++
 src/libs/game/gui/mainmenu.cpp               |  2 +
 test/fixtures/resource.h                     |  1 +
 10 files changed, 193 insertions(+), 6 deletions(-)

diff --git a/include/reone/game/areamusicplayer.h b/include/reone/game/areamusicplayer.h
index 24f1748fb..bb1df0713 100644
--- a/include/reone/game/areamusicplayer.h
+++ b/include/reone/game/areamusicplayer.h
@@ -19,6 +19,7 @@
 
 #include <array>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -64,6 +65,15 @@ class AreaMusicPlayer : boost::noncopyable {
      */
     void init(bool tsl);
 
+    /**
+     * What hands over the playing load-screen music when the background
+     * music asks for the same track; it returns none when it does not. Only
+     * TSL sets it.
+     */
+    void setLoadMusicHandover(std::function<std::shared_ptr<audio::AudioSource>(const std::string &)> handover) {
+        _loadMusicHandover = std::move(handover);
+    }
+
     /**
      * Take the area being entered. Its music and ambient loop wait for the
      * start; whether each is on starts from what the area asks for.
@@ -139,6 +149,7 @@ class AreaMusicPlayer : boost::noncopyable {
     };
 
     ServicesView &_services;
+    std::function<std::shared_ptr<audio::AudioSource>(const std::string &)> _loadMusicHandover;
 
     // Tables
 
@@ -209,8 +220,12 @@ class AreaMusicPlayer : boost::noncopyable {
     bool isMusicPlaying();
     /** Whether the ambient loop sounds, a fading loop until its fade ends. */
     bool isAmbientPlaying();
-    /** Plays the music track \p resRef; false when it does not play. */
-    bool playTrack(const std::string &resRef);
+    /**
+     * Plays the music track \p resRef; false when it does not play.
+     * @param takeLoadMusic whether the playing load-screen music of the same
+     *        track is taken over instead, as the background music does
+     */
+    bool playTrack(const std::string &resRef, bool takeLoadMusic = false);
     /** Fades out the music that is playing. */
     void fadeAndStop();
     /** Plays one of the track's stingers at random, once the area has been arrived in. */
diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 0196bd75d..9e94f42c5 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -556,6 +556,14 @@ class Game : boost::noncopyable {
     // END KotOR I Pazaak lifecycle
 
     void startCharacterGeneration();
+
+    /**
+     * Sets the music the next loading screens play to the one the
+     * loading-screen table gives the module named \p moduleName.
+     */
+    void setLoadMusicForModule(const std::string &moduleName);
+    /** Stops the loading-screen music; the track stays set for the next loading screen. */
+    void stopLoadMusic();
     void startDialog(const std::shared_ptr<Object> &owner, const std::string &resRef,
                      GlobalFade::DialogTicket admission = {},
                      const std::shared_ptr<Object> &listener = nullptr);
@@ -679,6 +687,8 @@ class Game : boost::noncopyable {
             std::string startWaypoint;
             uint32_t pauseDay {0};
             uint32_t pauseTime {0};
+            /** The loading-screen music the save asks for. */
+            std::string loadMusic;
         };
 
         std::unique_ptr<resource::SaveSessionState> session;
@@ -1922,6 +1932,16 @@ class Game : boost::noncopyable {
     std::string _musicResRef;
     std::shared_ptr<audio::AudioSource> _music;
     AreaMusicPlayer _areaMusic;
+    /**
+     * The music loading screens play. It is set by a new game, a save load
+     * and the module picker, and kept from one load, and one session, to the
+     * next.
+     */
+    std::string _loadMusicResRef;
+    /** The loading-screen music that is playing, or paused under a movie. */
+    std::shared_ptr<audio::AudioSource> _loadMusic;
+    /** The coming module load follows transition movies, and plays no loading-screen music. */
+    bool _loadComesWithMovies {false};
 
     // END Audio
 
@@ -2049,6 +2069,10 @@ class Game : boost::noncopyable {
     bool loadParty();
     void loadNextModule();
     void playMusic(const std::string &resRef);
+    /** Starts, or resumes, the loading-screen music, as a loading screen does when it is shown. */
+    void startLoadMusic();
+    /** Hands the playing loading-screen music over to the background music when it asks for the same track. */
+    std::shared_ptr<audio::AudioSource> takeLoadMusic(const std::string &resRef);
     void toggleInGameCameraType();
     void enterFreeLook();
     void exitFreeLook();
diff --git a/include/reone/game/gui/loadscreen.h b/include/reone/game/gui/loadscreen.h
index bac7cd422..867d0d99b 100644
--- a/include/reone/game/gui/loadscreen.h
+++ b/include/reone/game/gui/loadscreen.h
@@ -43,6 +43,12 @@ class LoadingScreen : public GameGUI {
      * there is one, else the one the table's default row names.
      */
     void setModuleImage(const std::string &moduleName);
+    /**
+     * The music the loading screen of the module named \p moduleName plays:
+     * the one its row of the loading-screen table names, else its own load_
+     * track when there is one, else the one the table's default row names.
+     */
+    std::string musicResRef(const std::string &moduleName) const;
     void setProgress(int progress);
 
 private:
diff --git a/include/reone/resource/provider/audioclips.h b/include/reone/resource/provider/audioclips.h
index 0d5e0356a..5cd0a901f 100644
--- a/include/reone/resource/provider/audioclips.h
+++ b/include/reone/resource/provider/audioclips.h
@@ -39,6 +39,9 @@ class IAudioClips {
     virtual void clear() = 0;
 
     virtual std::shared_ptr<audio::AudioClip> get(const std::string &key) = 0;
+
+    /** Whether an MP3 named \p resRef is there, streamed or not; nothing is decoded. */
+    virtual bool hasMp3(const std::string &resRef) = 0;
 };
 
 /**
@@ -61,6 +64,10 @@ class AudioClips : public IAudioClips {
         _objects.clear();
     }
 
+    bool hasMp3(const std::string &resRef) override {
+        return findClipData(resRef, ResType::Mp3).has_value();
+    }
+
     std::shared_ptr<audio::AudioClip> get(const std::string &key) override {
         auto maybeObject = _objects.find(key);
         if (maybeObject != _objects.end()) {
diff --git a/src/libs/game/areamusicplayer.cpp b/src/libs/game/areamusicplayer.cpp
index 579b86263..114052c46 100644
--- a/src/libs/game/areamusicplayer.cpp
+++ b/src/libs/game/areamusicplayer.cpp
@@ -139,10 +139,20 @@ bool AreaMusicPlayer::isAmbientPlaying() {
     return _ambient && _ambient->isPlaying();
 }
 
-bool AreaMusicPlayer::playTrack(const std::string &resRef) {
+bool AreaMusicPlayer::playTrack(const std::string &resRef, bool takeLoadMusic) {
     if (resRef.empty()) {
         return false;
     }
+    // TSL's background music takes over the load-screen music when it is the
+    // same track, and lets it play on, once through.
+    if (takeLoadMusic && _loadMusicHandover) {
+        if (auto loadMusic = _loadMusicHandover(resRef)) {
+            _music = std::move(loadMusic);
+            _fadeEnd.reset();
+            _playingResRef = resRef;
+            return true;
+        }
+    }
     _music = _services.audio.mixer.play(_services.resource.audioClips.get(resRef), AudioType::Music, _musicGroupGain);
     _fadeEnd.reset();
     _playingResRef = resRef;
@@ -247,7 +257,7 @@ void AreaMusicPlayer::switchMusic(bool play) {
     if (play) {
         if (!isMusicPlaying()) {
             _countdown = 0;
-            if (!playTrack(track(_area->ambientAudio().musicDay).resRef)) {
+            if (!playTrack(track(_area->ambientAudio().musicDay).resRef, true)) {
                 _countdown = kMusicRetryMilliseconds;
             }
         }
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 9382fb27c..6ee3c5891 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -689,6 +689,11 @@ void Game::initTables() {
 
     _trapTypes = Trap::readTypes(twoDas);
     _areaMusic.init(isTSL());
+    if (isTSL()) {
+        _areaMusic.setLoadMusicHandover([this](const std::string &resRef) {
+            return takeLoadMusic(resRef);
+        });
+    }
     _party.init();
 }
 
@@ -1940,6 +1945,8 @@ void Game::retireRuntimeSession() {
 
     _services.audio.mixer.stopAll();
     _music.reset();
+    _loadMusic.reset();
+    _loadComesWithMovies = false;
     _movie.reset();
     _musicResRef.clear();
     while (!_moduleTransitionMovies.empty()) {
@@ -2116,6 +2123,7 @@ Game::PreparedSaveLoad Game::prepareSaveLoad(const resource::SaveSlotDescriptor
         }
         autosave.pauseDay = params->getUint("TIME_PAUSEDAY");
         autosave.pauseTime = params->getUint("TIME_PAUSETIME");
+        autosave.loadMusic = params->getString("LOADMUSIC");
         prepared.autosave = std::move(autosave);
     }
     validatePartyLoad(prepared.partyTable.get());
@@ -2135,6 +2143,12 @@ bool Game::loadGame(const resource::SaveSlotDescriptor &slot) {
         // Commit. The old runtime and the old mounts retire together, and only
         // then does the candidate become authoritative: no runtime ever
         // observes the other session's resources.
+        // A save loads with no loading-screen music, except an autosave of the
+        // world's template, which plays the one it recorded.
+        _loadMusicResRef.clear();
+        if (prepared.autosave) {
+            _loadMusicResRef = prepared.autosave->loadMusic;
+        }
         resetGame();
         _services.resource.director.commitGameLoad(std::move(prepared.session));
         return restoreSaveLoad(std::move(prepared));
@@ -2859,6 +2873,8 @@ void Game::setCursorType(CursorType type) {
 
 void Game::playVideo(const std::string &name, bool streamingMusic) {
     _moduleTransitionMovies = std::queue<std::string>();
+    // A script's movie empties the transition list when it ends.
+    _loadComesWithMovies = false;
     startVideo(name, streamingMusic);
 }
 
@@ -2877,6 +2893,61 @@ void Game::playMusic(const std::string &resRef) {
     }
 }
 
+// A new game, TSL's character generation and the module picker set the
+// loading-screen music from the module's row of the loading-screen table.
+void Game::setLoadMusicForModule(const std::string &moduleName) {
+    if (!_loadScreen) {
+        _loadScreen = tryLoadGUI<LoadingScreen>();
+    }
+    _loadMusicResRef = _loadScreen ? _loadScreen->musicResRef(moduleName) : "";
+}
+
+// Every loading screen shown with music starts it: the menu music stops;
+// nothing starts while transition movies are listed for the load; music that
+// is there but not playing is resumed; else the set track starts, looping, in
+// the streamed music group, at that group's volume.
+void Game::startLoadMusic() {
+    playMusic("");
+    if (_loadComesWithMovies) {
+        return;
+    }
+    if (_loadMusic) {
+        if (!_loadMusic->isPlaying()) {
+            _loadMusic->resume();
+        }
+        return;
+    }
+    if (_loadMusicResRef.empty()) {
+        return;
+    }
+    _loadMusic = _services.audio.mixer.play(
+        _services.resource.audioClips.get(_loadMusicResRef),
+        AudioType::Music,
+        _areaMusic.musicGroupGain(),
+        true);
+}
+
+// KotOR's loading screen stops the loading music when it goes; both titles
+// stop it when the area's sounds start, and TSL when character generation
+// ends.
+void Game::stopLoadMusic() {
+    if (_loadMusic) {
+        _loadMusic->stop();
+        _loadMusic.reset();
+    }
+}
+
+// The playing loading music, when it is the track asked for (ignoring case),
+// becomes the background music and plays once through.
+std::shared_ptr<AudioSource> Game::takeLoadMusic(const std::string &resRef) {
+    if (!_loadMusic || !boost::iequals(resRef, _loadMusicResRef)) {
+        return nullptr;
+    }
+    auto music = std::move(_loadMusic);
+    music->setLooping(false);
+    return music;
+}
+
 void Game::renderScene() {
     if (!_module || !_options.graphics.sceneRender) {
         _lastRenderedSceneOutput = nullptr;
@@ -4472,6 +4543,7 @@ void Game::settleFadeArrival() {
         if (_musicResRef.empty()) {
             _areaMusic.start();
         }
+        stopLoadMusic();
         _globalFade.settleArrival(_fadeArrival);
     }
     _fadeArrival.reset();
@@ -4931,6 +5003,11 @@ bool Game::playNextModuleTransitionMovie() {
         _moduleTransitionMovies.pop();
 
         if (startVideo(name, false)) {
+            // A transition list holds only movies that exist, and its load
+            // plays no loading-screen music.
+            if (!_nextModule.empty()) {
+                _loadComesWithMovies = true;
+            }
             return true;
         }
     }
@@ -5605,7 +5682,15 @@ void Game::withLoadingScreen(const std::string &moduleName, const std::function<
     }
     changeScreen(Screen::Loading);
     render();
+    startLoadMusic();
     block();
+    // KotOR's loading screen takes its music with it; TSL's plays on until
+    // the area's sounds start. The transition list is cleared at the load's
+    // end.
+    if (!isTSL()) {
+        stopLoadMusic();
+    }
+    _loadComesWithMovies = false;
     // Player input returns once a load is done.
     _playerInputBlocked = false;
 }
@@ -8390,11 +8475,18 @@ void Game::startCharacterGeneration() {
     }
     // Character generation loads as the class selection does, and every new
     // character starts from a new class selection.
+    // TSL's character generation plays its loading screen's music throughout;
+    // KotOR's plays its menu music once the panel is up.
+    if (isTSL()) {
+        setLoadMusicForModule(kClassSelectionLoadScreen);
+    }
     withLoadingScreen(kClassSelectionLoadScreen, [this]() {
         _charGen->startCreation();
         _loadScreen->setProgress(100);
         render();
-        playMusic(_charGen->musicResRef());
+        if (!isTSL()) {
+            playMusic(_charGen->musicResRef());
+        }
         changeScreen(Screen::CharacterGeneration);
     });
 }
diff --git a/src/libs/game/gui/chargen.cpp b/src/libs/game/gui/chargen.cpp
index 384010f38..b1d5bf00b 100644
--- a/src/libs/game/gui/chargen.cpp
+++ b/src/libs/game/gui/chargen.cpp
@@ -86,7 +86,9 @@ CharacterGeneration::CharacterGeneration(Game &game, ServicesView &services) :
     GameGUI(game, services) {
     _resRef = guiResRef("maincg");
 
-    _musicResRef = game.isTSL() ? "mus_main" : "mus_theme_rep";
+    // KotOR's character generation plays its own menu music; TSL's plays its
+    // loading screen's music instead, from the loading-screen table.
+    _musicResRef = game.isTSL() ? "" : "mus_theme_rep";
 }
 
 void CharacterGeneration::onGUILoaded() {
@@ -558,6 +560,12 @@ void CharacterGeneration::finish() {
         }
 
         std::string moduleName(!_game.isTSL() ? "end_m01aa" : "001ebo");
+        // The new game's loading screen plays the module's music; TSL first
+        // stops character generation's.
+        if (_game.isTSL()) {
+            _game.stopLoadMusic();
+        }
+        _game.setLoadMusicForModule(moduleName);
         _game.loadModule(moduleName);
     }
 }
diff --git a/src/libs/game/gui/loadscreen.cpp b/src/libs/game/gui/loadscreen.cpp
index 510da1715..bd8c36e73 100644
--- a/src/libs/game/gui/loadscreen.cpp
+++ b/src/libs/game/gui/loadscreen.cpp
@@ -20,6 +20,7 @@
 #include "reone/game/game.h"
 #include "reone/game/twodautil.h"
 #include "reone/resource/2da.h"
+#include "reone/resource/provider/audioclips.h"
 #include "reone/resource/resources.h"
 
 using namespace reone::audio;
@@ -67,6 +68,27 @@ void LoadingScreen::setModuleImage(const std::string &moduleName) {
     _gui->rootControl().setBorderFill(image);
 }
 
+// The music of the loading-screen table's row named by the module; failing
+// that, load_<module> when that MP3 exists; else the default row's. No module
+// name gives no music.
+std::string LoadingScreen::musicResRef(const std::string &moduleName) const {
+    static constexpr char kMusicColumn[] = "musicresref";
+    static constexpr char kDefaultRow[] = "default";
+    if (moduleName.empty()) {
+        return "";
+    }
+    const int row = _loadScreens->indexByLabel(moduleName);
+    if (auto named = row != -1 ? _loadScreens->getStringOpt(row, kMusicColumn) : std::nullopt) {
+        return *named;
+    }
+    if (const std::string own = "load_" + moduleName;
+        _services.resource.audioClips.hasMp3(own)) {
+        return own;
+    }
+    const int defaultRow = _loadScreens->indexByLabel(kDefaultRow);
+    return defaultRow != -1 ? _loadScreens->getStringOpt(defaultRow, kMusicColumn).value_or("") : "";
+}
+
 void LoadingScreen::setProgress(int progress) {
     _controls.PB_PROGRESS->setValue(progress);
 }
diff --git a/src/libs/game/gui/mainmenu.cpp b/src/libs/game/gui/mainmenu.cpp
index dbbf85e2f..b29e3086b 100644
--- a/src/libs/game/gui/mainmenu.cpp
+++ b/src/libs/game/gui/mainmenu.cpp
@@ -266,7 +266,9 @@ void MainMenu::loadModuleNames() {
     }
 }
 
+// Picking a module sets its loading-screen music.
 void MainMenu::onModuleSelected(const std::string &name) {
+    _game.setLoadMusicForModule(name);
     _game.loadModule(name);
 }
 
diff --git a/test/fixtures/resource.h b/test/fixtures/resource.h
index 7ce8b3848..bfa70541a 100644
--- a/test/fixtures/resource.h
+++ b/test/fixtures/resource.h
@@ -128,6 +128,7 @@ class MockAudioClips : public IAudioClips, boost::noncopyable {
 public:
     MOCK_METHOD(void, clear, (), (override));
     MOCK_METHOD(std::shared_ptr<audio::AudioClip>, get, (const std::string &key), (override));
+    MOCK_METHOD(bool, hasMp3, (const std::string &resRef), (override));
 };
 
 class MockCursors : public ICursors, boost::noncopyable {

From 9b02687397a55e937fd276657ab5e157c9262187 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:25:14 -0400
Subject: [PATCH 18/23] While a conversation that is an animated cutscene owns
 the screen, a creature or placeable playing an animation authored in world
 space (the cut bands from 1200 and from 1600) takes no other animation: no
 pose, script animation, one-shot, overlay, flinch, return to its loop or
 state-driven refresh. It keeps the clip, and its last frame once a one-shot
 has run, until the conversation's animation list gives it a new animation or
 releases it, or the cutscene closes. The game refuses every animation request
 in that state and clears the hold only from the dialog's animation lists.

---
 include/reone/game/game.h                 | 11 ++++++
 include/reone/game/gui/conversation.h     |  3 ++
 include/reone/game/gui/ingame/inventory.h |  4 ++
 include/reone/game/object.h               | 11 ++++++
 include/reone/game/presentationgui.h      |  5 +++
 src/libs/game/game.cpp                    | 23 +++++++++++
 src/libs/game/gui/chargen.cpp             |  3 ++
 src/libs/game/gui/dialog.cpp              |  8 ++++
 src/libs/game/gui/ingame/abilities.cpp    |  1 +
 src/libs/game/gui/ingame/character.cpp    |  1 +
 src/libs/game/gui/ingame/equip.cpp        |  1 +
 src/libs/game/gui/ingame/inventory.cpp    |  6 +++
 src/libs/game/gui/saveload.cpp            |  4 ++
 src/libs/game/object.cpp                  |  5 +++
 src/libs/game/object/creature.cpp         | 48 +++++++++++++++++++++++
 src/libs/game/object/placeable.cpp        | 16 ++++++++
 src/libs/game/presentationgui.cpp         |  9 +++++
 17 files changed, 159 insertions(+)

diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 9e94f42c5..7d3419902 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -564,6 +564,12 @@ class Game : boost::noncopyable {
     void setLoadMusicForModule(const std::string &moduleName);
     /** Stops the loading-screen music; the track stays set for the next loading screen. */
     void stopLoadMusic();
+    /**
+     * Fades the menu music out for a fixed wait and then stops it, holding
+     * everything else meanwhile, as starting a new game or loading a save
+     * from the main menu does.
+     */
+    void fadeOutMenuMusic();
     void startDialog(const std::shared_ptr<Object> &owner, const std::string &resRef,
                      GlobalFade::DialogTicket admission = {},
                      const std::shared_ptr<Object> &listener = nullptr);
@@ -618,6 +624,11 @@ class Game : boost::noncopyable {
         return _screen == Screen::Conversation;
     }
 
+    /** A conversation owns the screen, and its dialog is an animated cutscene. */
+    bool isAnimatedCutsceneShowing() const {
+        return isConversationActive() && _conversation && _conversation->isAnimatedCutscene();
+    }
+
     /** The object is the running dialogue's current speaker or listener. */
     bool isConversationSpeakerOrListener(const Object &object) const {
         return isConversationActive() && _conversation == _dialog.get() && _dialog->isSpeakerOrListener(object);
diff --git a/include/reone/game/gui/conversation.h b/include/reone/game/gui/conversation.h
index f3547f672..68f963d96 100644
--- a/include/reone/game/gui/conversation.h
+++ b/include/reone/game/gui/conversation.h
@@ -82,6 +82,9 @@ class Conversation : public GameGUI {
 
     void setAutoSkip(AutoSkip *skip) { _autoSkip = skip; }
 
+    /** The conversation's dialog is an animated cutscene. */
+    bool isAnimatedCutscene() const { return _dialog && _dialog->isAnimatedCutscene(); }
+
 protected:
     std::shared_ptr<Object> owner() const { return _owner.resolve(); }
     std::shared_ptr<resource::Dialog> _dialog;
diff --git a/include/reone/game/gui/ingame/inventory.h b/include/reone/game/gui/ingame/inventory.h
index a3ebfb2ea..87d55036b 100644
--- a/include/reone/game/gui/ingame/inventory.h
+++ b/include/reone/game/gui/ingame/inventory.h
@@ -61,6 +61,8 @@ class InventoryMenu : public PresentationGUI {
         std::shared_ptr<gui::Button> BTN_ARMOR;
         std::shared_ptr<gui::Button> BTN_CHANGE1;
         std::shared_ptr<gui::Button> BTN_CHANGE2;
+        std::shared_ptr<gui::Button> BTN_CHARLEFT;
+        std::shared_ptr<gui::Button> BTN_CHARRIGHT;
         std::shared_ptr<gui::Button> BTN_DATAPADS;
         std::shared_ptr<gui::Button> BTN_EXIT;
         std::shared_ptr<gui::Button> BTN_MISC;
@@ -119,6 +121,8 @@ class InventoryMenu : public PresentationGUI {
         _controls.BTN_ARMOR = findControl<gui::Button>("BTN_ARMOR");
         _controls.BTN_CHANGE1 = findControl<gui::Button>("BTN_CHANGE1");
         _controls.BTN_CHANGE2 = findControl<gui::Button>("BTN_CHANGE2");
+        _controls.BTN_CHARLEFT = findControl<gui::Button>("BTN_CHARLEFT");
+        _controls.BTN_CHARRIGHT = findControl<gui::Button>("BTN_CHARRIGHT");
         _controls.BTN_DATAPADS = findControl<gui::Button>("BTN_DATAPADS");
         _controls.BTN_EXIT = findControl<gui::Button>("BTN_EXIT");
         _controls.BTN_MISC = findControl<gui::Button>("BTN_MISC");
diff --git a/include/reone/game/object.h b/include/reone/game/object.h
index 1f310d536..cce99eb62 100644
--- a/include/reone/game/object.h
+++ b/include/reone/game/object.h
@@ -368,6 +368,15 @@ class Object : public scene::IUser, boost::noncopyable {
      */
     void setPlacedAtOrigin(bool placed);
 
+    /**
+     * Whether the object takes no other animation: while an animated
+     * cutscene is showing, an object playing an animation authored in world
+     * space keeps it until the conversation's animation list releases it.
+     */
+    bool holdsCutsceneAnimation() const;
+    /** The conversation's animation list releases the object's world-space animation. */
+    void releaseCutsceneAnimation() { _playingCutsceneAnimation = false; }
+
     // END Stunt mode
 
     // Hit Points
@@ -730,6 +739,8 @@ class Object : public scene::IUser, boost::noncopyable {
     bool _stunt {false};
     /** Stunt mode was entered for a world-space animation and ends with it. */
     bool _placedAtOrigin {false};
+    /** The object last took an animation authored in world space, and no animation list has released it. */
+    bool _playingCutsceneAnimation {false};
     std::string _activeAnimName;
     std::string _feedbackText;
     float _feedbackTextRemaining {0.0f};
diff --git a/include/reone/game/presentationgui.h b/include/reone/game/presentationgui.h
index 4af1c1d80..b2b0d94ef 100644
--- a/include/reone/game/presentationgui.h
+++ b/include/reone/game/presentationgui.h
@@ -140,6 +140,11 @@ class PresentationGUI : public gui::IGUIEventListener, boost::noncopyable {
     void fillK2SectionStrip(const std::shared_ptr<gui::Control> &topBar, const std::shared_ptr<gui::Control> &bottomBar);
     void useK2ShellTitle(const std::shared_ptr<gui::Control> &control);
     void updateK2FilterButton(const std::shared_ptr<gui::Control> &button, bool selected);
+    /**
+     * Turns KotOR's right party arrow to point right: the layouts give both
+     * arrows beside the party portraits the left-pointing art.
+     */
+    void turnK1PartyArrowRight();
 
     virtual void configureControls() {}
     void onClick(const std::string &control) override;
diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 6ee3c5891..7ee17c008 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -26,6 +26,9 @@
 #include <numeric>
 #include <optional>
 
+#include <chrono>
+#include <thread>
+
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <imgui.h>
@@ -2937,6 +2940,26 @@ void Game::stopLoadMusic() {
     }
 }
 
+// The menu music fades out over 2500 ms; only the sound runs until 750 ms have
+// passed, and then the menu music stops at once.
+static constexpr uint32_t kMenuMusicFadeMilliseconds = 2500;
+static constexpr uint32_t kMenuMusicWaitMilliseconds = 750;
+
+// The wait is real time.
+void Game::fadeOutMenuMusic() {
+    using namespace std::chrono;
+    const auto start = steady_clock::now();
+    for (auto elapsed = milliseconds(0); elapsed < milliseconds(kMenuMusicWaitMilliseconds);
+         elapsed = duration_cast<milliseconds>(steady_clock::now() - start)) {
+        if (_music) {
+            _music->setGainScale(1.0f - static_cast<float>(elapsed.count()) / kMenuMusicFadeMilliseconds);
+        }
+        _services.audio.mixer.render();
+        std::this_thread::sleep_for(milliseconds(1));
+    }
+    playMusic("");
+}
+
 // The playing loading music, when it is the track asked for (ignoring case),
 // becomes the background music and plays once through.
 std::shared_ptr<AudioSource> Game::takeLoadMusic(const std::string &resRef) {
diff --git a/src/libs/game/gui/chargen.cpp b/src/libs/game/gui/chargen.cpp
index b1d5bf00b..fa77ec9bb 100644
--- a/src/libs/game/gui/chargen.cpp
+++ b/src/libs/game/gui/chargen.cpp
@@ -559,6 +559,9 @@ void CharacterGeneration::finish() {
             _game.setGlobalNumber(kPlayerLevelGlobal, player->attributes().getAggregateLevel());
         }
 
+        // Starting the game first fades the menu music out.
+        _game.fadeOutMenuMusic();
+
         std::string moduleName(!_game.isTSL() ? "end_m01aa" : "001ebo");
         // The new game's loading screen plays the module's music; TSL first
         // stops character generation's.
diff --git a/src/libs/game/gui/dialog.cpp b/src/libs/game/gui/dialog.cpp
index 074d81426..a32c7f838 100644
--- a/src/libs/game/gui/dialog.cpp
+++ b/src/libs/game/gui/dialog.cpp
@@ -703,6 +703,10 @@ void DialogGUI::updateParticipantAnimations(const Dialog::EntryReply &node) {
         if (!cut && !_services.game.animations.isDialogAnimation(anim.animation)) {
             continue;
         }
+        // A new animation from the list releases a world-space one.
+        if (object) {
+            object->releaseCutsceneAnimation();
+        }
         if (auto placeable = std::dynamic_pointer_cast<Placeable>(object)) {
             applyPlaceableAnimation(*placeable, anim.animation, cut);
             continue;
@@ -743,6 +747,7 @@ std::vector<std::shared_ptr<Object>> DialogGUI::participantObjects(const std::ma
 void DialogGUI::releaseParticipants(const std::vector<std::shared_ptr<Object>> &participants) {
     for (const auto &object : participants) {
         if (auto placeable = std::dynamic_pointer_cast<Placeable>(object)) {
+            placeable->releaseCutsceneAnimation();
             placeable->showStateAnimation();
             continue;
         }
@@ -750,6 +755,7 @@ void DialogGUI::releaseParticipants(const std::vector<std::shared_ptr<Object>> &
         if (!creature || !canPlayDialogAnimations(*creature)) {
             continue;
         }
+        creature->releaseCutsceneAnimation();
         creature->setHeadLookSuspended(false);
         creature->showDialogPause();
     }
@@ -1019,9 +1025,11 @@ void DialogGUI::releaseStuntParticipants() {
         _participantByTag.clear();
         return;
     }
+    // The animated cutscene is over, and holds no one.
     for (auto &participant : _participantByTag) {
         auto creature = participant.second.creature.resolve();
         if (!creature) continue;
+        creature->releaseCutsceneAnimation();
         creature->resumeStateDrivenAnimation();
         creature->setIsInConversation(false);
     }
diff --git a/src/libs/game/gui/ingame/abilities.cpp b/src/libs/game/gui/ingame/abilities.cpp
index 0ce3cedcc..3175bbfa2 100644
--- a/src/libs/game/gui/ingame/abilities.cpp
+++ b/src/libs/game/gui/ingame/abilities.cpp
@@ -50,6 +50,7 @@ void AbilitiesMenu::onGUILoaded() {
     bindControls();
     tintK2InGameFooter();
     tintK2InGameHeader();
+    turnK1PartyArrowRight();
 
     _controls.BTN_SKILLS->setDisabled(true);
     _controls.BTN_POWERS->setDisabled(true);
diff --git a/src/libs/game/gui/ingame/character.cpp b/src/libs/game/gui/ingame/character.cpp
index f6aa7c718..0c7ed8436 100644
--- a/src/libs/game/gui/ingame/character.cpp
+++ b/src/libs/game/gui/ingame/character.cpp
@@ -131,6 +131,7 @@ void CharacterMenu::onGUILoaded() {
         _controls.BTN_CHANGE2 = _inGameMenu.getBtnChange3();
     }
 
+    turnK1PartyArrowRight();
     _controls.BTN_AUTO->setDisabled(true);
     // The level-up buttons' texts pulse until the pointer first leaves them.
     _controls.BTN_AUTO->setTextPulsing(true);
diff --git a/src/libs/game/gui/ingame/equip.cpp b/src/libs/game/gui/ingame/equip.cpp
index fe86dbf62..b9d256ec2 100644
--- a/src/libs/game/gui/ingame/equip.cpp
+++ b/src/libs/game/gui/ingame/equip.cpp
@@ -120,6 +120,7 @@ void Equipment::onGUILoaded() {
         _btnInv[slotName.first] = findControl<Button>("BTN_INV_" + slotName.second);
     }
 
+    turnK1PartyArrowRight();
     // The portraits beside the shown character give control to those members.
     if (_controls.BTN_CHANGE1) {
         _controls.BTN_CHANGE1->setOnClick([this]() { changeCharacter(1); });
diff --git a/src/libs/game/gui/ingame/inventory.cpp b/src/libs/game/gui/ingame/inventory.cpp
index 030746ef8..815d57385 100644
--- a/src/libs/game/gui/ingame/inventory.cpp
+++ b/src/libs/game/gui/ingame/inventory.cpp
@@ -150,6 +150,12 @@ void InventoryMenu::onGUILoaded() {
         if (_controls.BTN_CHANGE2) {
             _controls.BTN_CHANGE2->setSelectable(false);
         }
+        // KotOR's inventory has no party arrows.
+        for (auto &arrow : {_controls.BTN_CHARLEFT, _controls.BTN_CHARRIGHT}) {
+            if (arrow) {
+                arrow->setVisible(false);
+            }
+        }
     }
 }
 
diff --git a/src/libs/game/gui/saveload.cpp b/src/libs/game/gui/saveload.cpp
index 0d6394b4a..6702ea72b 100644
--- a/src/libs/game/gui/saveload.cpp
+++ b/src/libs/game/gui/saveload.cpp
@@ -453,6 +453,10 @@ void SaveLoad::loadGame(uint32_t number) {
     auto save = findSave(number);
     if (!save) return;
     try {
+        // A load from the main menu first fades the menu music out.
+        if (_mode == SaveLoadMode::LoadFromMainMenu) {
+            _game.fadeOutMenuMusic();
+        }
         // Hand over the slot discovered by indexing. Reducing it to a name here
         // would make the loader resolve the directory a second time, and the
         // entity it found need not be the one the player selected.
diff --git a/src/libs/game/object.cpp b/src/libs/game/object.cpp
index a007143c2..9d88e9db2 100644
--- a/src/libs/game/object.cpp
+++ b/src/libs/game/object.cpp
@@ -2025,12 +2025,17 @@ void Object::setPlacedAtOrigin(bool placed) {
         }
         return;
     }
+    _playingCutsceneAnimation = true;
     if (!_stunt) {
         startStuntMode();
         _placedAtOrigin = true;
     }
 }
 
+bool Object::holdsCutsceneAnimation() const {
+    return _playingCutsceneAnimation && _game.isAnimatedCutsceneShowing();
+}
+
 std::shared_ptr<Effect> Object::getFirstEffect() {
     _effectIndex = 0;
     return getNextEffect();
diff --git a/src/libs/game/object/creature.cpp b/src/libs/game/object/creature.cpp
index 8e51b02f5..a4f67f540 100644
--- a/src/libs/game/object/creature.cpp
+++ b/src/libs/game/object/creature.cpp
@@ -2947,6 +2947,10 @@ static std::optional<std::reference_wrapper<const StatePose>> findStatePose(int
 }
 
 void Creature::updateModelAnimation() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (!model) {
         return;
@@ -3155,6 +3159,10 @@ void Creature::animateFireAndForget(float dt) {
 // A layer plays at its natural speed over the loop, so its time only paces
 // the queue. A swing starting carries its attack to its hit.
 void Creature::playTopFireForgetAnimation() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     static constexpr int kMinFireForgetMilliseconds = 50;
     const FireForgetEntry entry = std::move(_fireForgetQueue.front());
     _fireForgetQueue.pop_front();
@@ -3191,6 +3199,10 @@ void Creature::playTopFireForgetAnimation() {
 // it ran; a loop still running under a layer carries on. A pose chosen
 // meanwhile goes through the pose path.
 void Creature::returnToStoredLoop() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     // Returning to the loop shows again the items a one-shot put away.
     presentEquippedItems(_storedLoop ? _storedLoop->clip : getActiveAnimationName());
     if (_animDirty) {
@@ -3312,6 +3324,10 @@ void Creature::setAnimationSource(AnimationSource source) {
 // A creature still loading has no model yet; it shows nothing, so it queues nothing.
 void Creature::addFireForgetAnimation(const std::string &clip, int lengthMilliseconds, float rate, bool layered,
                                       AnimationSource source, std::optional<SwingAttack> attack) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     if (!_sceneNode) {
         return;
     }
@@ -3338,6 +3354,10 @@ bool Creature::addFireForgetAnimation(const std::string &clip, bool layered, Ani
 }
 
 void Creature::abortFireForgetAnimation(bool clearLayers) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (clearLayers && model) {
         model->removeLayers();
@@ -4570,6 +4590,10 @@ void Creature::playAnimation(AnimationType type, AnimationProperties properties,
 }
 
 void Creature::playAnimation(const std::string &name, AnimationProperties properties, AnimationSource source) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     bool fireForget = !(properties.flags & AnimationFlags::loop);
     // A clip the model lacks shows nothing and leaves the current one running.
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
@@ -4610,6 +4634,10 @@ bool Creature::doPlayAnimation(bool fireForget, const std::function<void()> &cal
 }
 
 bool Creature::playAnimation(const std::shared_ptr<Animation> &anim, AnimationProperties properties) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return false;
+    }
     bool fireForget = !(properties.flags & AnimationFlags::loop);
 
     return doPlayAnimation(fireForget, [&]() {
@@ -4630,6 +4658,10 @@ bool Creature::playAnimation(const std::shared_ptr<Animation> &anim, AnimationPr
 // once; when it ends the creature returns to the pause.
 bool Creature::playExternalAnimation(const std::shared_ptr<Animation> &anim, AnimationProperties properties,
                                      AnimationSource source) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return false;
+    }
     const bool fireForget = !(properties.flags & AnimationFlags::loop);
     if (fireForget) {
         showDialogPause();
@@ -4671,6 +4703,10 @@ void Creature::playOverlayAnimation(AnimationType type) {
 }
 
 void Creature::playOverlayAnimation(const std::string &clip) {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (!model) {
         return;
@@ -4857,6 +4893,10 @@ bool Creature::isPlayingOneShotAnimation() const {
 }
 
 void Creature::resumeStateDrivenAnimation() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     _oneShot.reset();
     _animFireForget = false;
     _animDirty = true;
@@ -4939,6 +4979,10 @@ void Creature::releaseCastAnimation() {
 // Hands with no flinch row take the pose again each time, unless it still
 // shows. The flinch replaces what the creature was last given.
 void Creature::playDamageFlinch() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     const std::string name = getDamageFlinchAnimation();
     if (name.empty()) {
         if (!showsDamageFlinchPose()) {
@@ -4960,6 +5004,10 @@ void Creature::playDamageFlinch() {
 // The time left of a cut queued one-shot stays too, without counting down, and
 // a new loop then waits for the pose to be ended otherwise.
 void Creature::holdDamageFlinchPose() {
+    // A world-space animation of an animated cutscene holds the creature.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     static const std::string kPoseClip("pause1");
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (!model || !model->model().getAnimation(kPoseClip)) {
diff --git a/src/libs/game/object/placeable.cpp b/src/libs/game/object/placeable.cpp
index dde679b23..34b2535cd 100644
--- a/src/libs/game/object/placeable.cpp
+++ b/src/libs/game/object/placeable.cpp
@@ -708,6 +708,10 @@ static std::string getPlaceableClip(const IAnimations &animations, int id) {
 // swing the model lacks is passed over.
 void Placeable::setStateAnimation(int animation) {
     _animation = animation;
+    // A world-space animation of an animated cutscene holds the placeable.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (_isCorpse || !model || animation == _shownAnimation) {
         return;
@@ -744,6 +748,10 @@ bool Placeable::playsAnimationOnce(int id) const {
 
 // The loop that follows a one-shot stands where the placeable does.
 void Placeable::updateOpenStateAnimation() {
+    // A world-space animation of an animated cutscene holds the placeable.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     if (_openStateLoop.empty() || !model) {
         return;
@@ -759,6 +767,10 @@ void Placeable::updateOpenStateAnimation() {
 }
 
 bool Placeable::showAnimationLoop(int id) {
+    // A world-space animation of an animated cutscene holds the placeable.
+    if (holdsCutsceneAnimation()) {
+        return false;
+    }
     auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
     const std::string clip = getPlaceableClip(_services.game.animations, id);
     if (_isCorpse || !model || clip.empty() || !model->model().getAnimation(clip)) {
@@ -775,6 +787,10 @@ bool Placeable::showAnimationLoop(int id) {
 // The default pose comes first: a loop the model lacks leaves it, and a
 // one-shot returns to it.
 void Placeable::playDialogAnimation(int id, bool looping) {
+    // A world-space animation of an animated cutscene holds the placeable.
+    if (holdsCutsceneAnimation()) {
+        return;
+    }
     if (looping) {
         if (!showAnimationLoop(id)) {
             showAnimationLoop(kDefaultAnimationId);
diff --git a/src/libs/game/presentationgui.cpp b/src/libs/game/presentationgui.cpp
index 075e5f0df..c21fe122c 100644
--- a/src/libs/game/presentationgui.cpp
+++ b/src/libs/game/presentationgui.cpp
@@ -381,6 +381,15 @@ void PresentationGUI::updateK2FilterButton(const std::shared_ptr<Control> &butto
     button->setTextColor(selected ? glm::vec3 {1.0f} : _baseColor);
 }
 
+void PresentationGUI::turnK1PartyArrowRight() {
+    if (isTSL()) {
+        return;
+    }
+    auto arrow = _gui->findControl("BTN_CHARRIGHT");
+    arrow->setBorderFillTransform(Control::Border::FillTransform::Rotate180);
+    arrow->setHilightFillTransform(Control::Border::FillTransform::Rotate180);
+}
+
 std::string PresentationGUI::guiResRef(const std::string &base) const {
     return isTSL() ? base + "_p" : base;
 }

From 6256cce4927d7402bb3625114fd74cbe33a945d8 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Mon, 26 Oct 2026 02:05:35 -0400
Subject: [PATCH 19/23] test fix

---
 src/libs/game/game.cpp |  4 ++--
 test/fixtures/engine.h | 34 ++++++++++++++++++++++++++++++++--
 2 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/src/libs/game/game.cpp b/src/libs/game/game.cpp
index 7ee17c008..76504f263 100644
--- a/src/libs/game/game.cpp
+++ b/src/libs/game/game.cpp
@@ -618,8 +618,8 @@ void Game::init() {
     _moduleNames = _services.resource.director.moduleNames();
     _saveNames = _services.resource.director.saveNames();
 
-    // reone plays no start-up movie: the main menu opens, and its music
-    // starts, at once.
+    // No movie plays at start-up: the main menu opens, and its music starts,
+    // at once.
     openMainMenu();
 }
 
diff --git a/test/fixtures/engine.h b/test/fixtures/engine.h
index 44e0cef0b..f17acea3e 100644
--- a/test/fixtures/engine.h
+++ b/test/fixtures/engine.h
@@ -98,7 +98,7 @@ class TestEngine : boost::noncopyable {
         ON_CALL(_resourceModule->twoDas(), get(std::string("racialtypes"))).WillByDefault(testing::Return(racialTypes));
         _gameModule->races().init(_resourceModule->twoDas());
         // The combat tables the game loads at start, with no rows but an
-        // excitement of no duration.
+        // excitement of no duration and KotOR's experience table.
         testing::NiceMock<resource::MockTwoDAs> combatTables;
         ON_CALL(combatTables, get(testing::_)).WillByDefault(testing::Invoke(&TestEngine::defaultCombatTable));
         _gameModule->combatTables().init(combatTables, resource::GameID::KotOR);
@@ -166,11 +166,41 @@ class TestEngine : boost::noncopyable {
     /** The rows of racialtypes.2da a creature may name. */
     static constexpr int kRacialTypeCount = 9;
 
-    /** A combat table as the game loads it at start: no rows, but an excitement of no duration. */
+    /**
+     * A combat table as the game loads it at start: no rows, but an excitement
+     * of no duration and KotOR's experience table, which also covers the TSL
+     * levels the tests reach.
+     */
     static std::shared_ptr<resource::TwoDA> defaultCombatTable(const std::string &resRef) {
         if (resRef == "excitedduration") {
             return resource::TwoDA::Builder().columns({"duration"}).row({"0"}).row({"0"}).row({"0"}).build();
         }
+        if (resRef == "exptable") {
+            return resource::TwoDA::Builder()
+                .columns({"level", "xp"})
+                .row({"1", "0"})
+                .row({"2", "1000"})
+                .row({"3", "3000"})
+                .row({"4", "6000"})
+                .row({"5", "10000"})
+                .row({"6", "15000"})
+                .row({"7", "21000"})
+                .row({"8", "28000"})
+                .row({"9", "36000"})
+                .row({"10", "45000"})
+                .row({"11", "55000"})
+                .row({"12", "66000"})
+                .row({"13", "78000"})
+                .row({"14", "91000"})
+                .row({"15", "105000"})
+                .row({"16", "120000"})
+                .row({"17", "136000"})
+                .row({"18", "153000"})
+                .row({"19", "171000"})
+                .row({"20", "190000"})
+                .row({"21", "0xFFFFFFFF"})
+                .build();
+        }
         return resource::TwoDA::Builder().build();
     }
 

From fce4918f0694780ae12f885f4d062de5150a9839 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 18:32:43 -0400
Subject: [PATCH 20/23] - The camera wait belongs to the clip the entry's
 camera request named. The   animated camera remembers that clip, and the
 conversation waits only while   it is playing. A request whose clip the
 camera model lacks leaves the   earlier clip running, and that earlier clip,
 looping or not, no longer   holds the entry. - The character wait splits by
 title. KotOR waits while any listed creature   plays a dialog animation. TSL
 waits until one of them has stopped, so a TSL   conversation no longer stays
 on an entry while another listed creature is   still animating. Only
 creatures count; the placeable state that only this   wait read is gone.

---
 include/reone/game/object/camera/animated.h |  5 ++++-
 include/reone/game/object/placeable.h       |  4 ----
 src/libs/game/gui/conversation.cpp          |  2 +-
 src/libs/game/gui/dialog.cpp                | 21 +++++++++++++--------
 src/libs/game/object/camera/animated.cpp    | 20 ++++++++++++--------
 src/libs/game/object/placeable.cpp          | 10 ----------
 6 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/include/reone/game/object/camera/animated.h b/include/reone/game/object/camera/animated.h
index 4099f56b8..e7cf32f6d 100644
--- a/include/reone/game/object/camera/animated.h
+++ b/include/reone/game/object/camera/animated.h
@@ -61,13 +61,16 @@ class AnimatedCamera : public Camera {
      */
     static std::string getShotClipName(int ordinal);
 
-    bool isAnimationFinished() const;
+    /** Whether the clip the last request named is playing; a request whose clip is missing plays nothing. */
+    bool isRequestedClipPlaying() const;
 
     void setModel(std::shared_ptr<graphics::Model> model);
     void setFieldOfView(float fovy);
 
 private:
     std::shared_ptr<scene::ModelSceneNode> _model;
+    /** The clip the last request named; empty when it named none. */
+    std::string _requestedClip;
     float _fovy {kDefaultAnimCamFOV};
 
     float projectionFovy() const override;
diff --git a/include/reone/game/object/placeable.h b/include/reone/game/object/placeable.h
index 4cb471b66..21249d405 100644
--- a/include/reone/game/object/placeable.h
+++ b/include/reone/game/object/placeable.h
@@ -94,8 +94,6 @@ class Placeable : public Object {
      * pose. A world-space cut clip plays with the model at the world origin.
      */
     void playDialogAnimation(int id, bool looping);
-    /** The animation ID the placeable shows: a dialog one-shot while it plays, else its loop's; -1 for none. */
-    int currentAnimationId() const;
     /**
      * The placeable takes animation \p animation as its state. When the model
      * has the state's loop and does not show it already, the swing from the
@@ -342,8 +340,6 @@ class Placeable : public Object {
     std::string _openStateLoop;
     /** The animation whose loop the model shows; -1 while it shows none of its own. */
     int _shownAnimation {-1};
-    /** The dialog one-shot last played, by ID and clip, until a loop replaces it. */
-    std::optional<std::pair<int, std::string>> _dialogOneShot;
     std::shared_ptr<scene::WalkmeshSceneNode> _walkmesh;
 
     // Scripts
diff --git a/src/libs/game/gui/conversation.cpp b/src/libs/game/gui/conversation.cpp
index fe59f6be2..9f4a644b9 100644
--- a/src/libs/game/gui/conversation.cpp
+++ b/src/libs/game/gui/conversation.cpp
@@ -861,7 +861,7 @@ bool Conversation::isCameraAnimationPlaying() const {
         return false;
     }
     auto camera = _game.module()->area()->getCamera<AnimatedCamera>(CameraType::Animated);
-    return !camera->isAnimationFinished();
+    return camera->isRequestedClipPlaying();
 }
 
 void Conversation::stopVoice() {
diff --git a/src/libs/game/gui/dialog.cpp b/src/libs/game/gui/dialog.cpp
index a32c7f838..50d8a1029 100644
--- a/src/libs/game/gui/dialog.cpp
+++ b/src/libs/game/gui/dialog.cpp
@@ -1065,20 +1065,25 @@ void DialogGUI::onReplyTaken(const Dialog::EntryReply &reply) {
     }
 }
 
+// Only the creatures of the list count. KotOR waits while any of them plays a
+// dialog animation. TSL waits until one of them has stopped, so a list that
+// names no creature keeps it waiting.
 bool DialogGUI::isDialogAnimationPlaying() const {
+    const bool tsl = _game.isTSL();
     for (const auto &participant : _waitedParticipants) {
-        auto object = participantObject(participant);
-        int animationId = -1;
-        if (auto creature = std::dynamic_pointer_cast<Creature>(object)) {
-            animationId = creature->currentAnimationId();
-        } else if (auto placeable = std::dynamic_pointer_cast<Placeable>(object)) {
-            animationId = placeable->currentAnimationId();
+        auto creature = std::dynamic_pointer_cast<Creature>(participantObject(participant));
+        if (!creature) {
+            continue;
+        }
+        const bool animating = _services.game.animations.isDialogAnimation(creature->currentAnimationId());
+        if (tsl && !animating) {
+            return false;
         }
-        if (_services.game.animations.isDialogAnimation(animationId)) {
+        if (!tsl && animating) {
             return true;
         }
     }
-    return false;
+    return tsl;
 }
 
 // With subtitles off, the text shows only when no voice-over speaks the entry
diff --git a/src/libs/game/object/camera/animated.cpp b/src/libs/game/object/camera/animated.cpp
index 684495c24..a1f4a9fcb 100644
--- a/src/libs/game/object/camera/animated.cpp
+++ b/src/libs/game/object/camera/animated.cpp
@@ -17,6 +17,8 @@
 
 #include "reone/game/object/camera/animated.h"
 
+#include <boost/algorithm/string/predicate.hpp>
+
 #include "reone/game/di/services.h"
 #include "reone/graphics/types.h"
 #include "reone/scene/di/services.h"
@@ -85,22 +87,24 @@ std::string AnimatedCamera::getShotClipName(int ordinal) {
 }
 
 void AnimatedCamera::playAnimation(int ordinal) {
-    if (!_model) {
-        return;
-    }
-    auto name = getShotClipName(ordinal);
-    if (name.empty()) {
+    _requestedClip = getShotClipName(ordinal);
+    if (!_model || _requestedClip.empty()) {
         return;
     }
     AnimationProperties properties;
     if (ordinal >= kFirstLoopingCameraOrdinal && ordinal <= kLastLoopingCameraOrdinal) {
         properties.flags |= AnimationFlags::loop;
     }
-    _model->playAnimation(name, nullptr, std::move(properties));
+    _model->playAnimation(_requestedClip, nullptr, std::move(properties));
 }
 
-bool AnimatedCamera::isAnimationFinished() const {
-    return _model ? _model->isAnimationFinished() : false;
+// Only the clip the last request named counts: a clip the model lacks leaves
+// the earlier one running, and that one is not waited for.
+bool AnimatedCamera::isRequestedClipPlaying() const {
+    if (!_model || _requestedClip.empty() || _model->isAnimationFinished()) {
+        return false;
+    }
+    return boost::iequals(_model->activeAnimationName(), _requestedClip);
 }
 
 void AnimatedCamera::setModel(std::shared_ptr<Model> model) {
diff --git a/src/libs/game/object/placeable.cpp b/src/libs/game/object/placeable.cpp
index 34b2535cd..6b42af653 100644
--- a/src/libs/game/object/placeable.cpp
+++ b/src/libs/game/object/placeable.cpp
@@ -779,7 +779,6 @@ bool Placeable::showAnimationLoop(int id) {
     setPlacedAtOrigin(isWorldSpaceCutClip(id));
     _openStateLoop.clear();
     _shownAnimation = id;
-    _dialogOneShot.reset();
     model->playAnimation(clip, nullptr, AnimationProperties::fromFlags(AnimationFlags::loop));
     return true;
 }
@@ -806,15 +805,6 @@ void Placeable::playDialogAnimation(int id, bool looping) {
     setPlacedAtOrigin(isWorldSpaceCutClip(id));
     model->playAnimation(clip);
     _openStateLoop = getPlaceableClip(_services.game.animations, kDefaultAnimationId);
-    _dialogOneShot = std::make_pair(id, clip);
-}
-
-int Placeable::currentAnimationId() const {
-    auto model = std::static_pointer_cast<ModelSceneNode>(_sceneNode);
-    if (_dialogOneShot && model && model->activeAnimationName() == _dialogOneShot->second && !model->isAnimationFinished()) {
-        return _dialogOneShot->first;
-    }
-    return _shownAnimation;
 }
 
 void Placeable::showStateAnimation() {

From f152f9c0f34c3e4f94dd6dd6543e2f64b7360491 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Wed, 28 Oct 2026 09:38:28 -0400
Subject: [PATCH 21/23] A conversation request is done once it has started its
 conversation, and the conversation owns its admission from then on. The
 opening entry's scripts run as the conversation starts, so a script that
 clears the requester's actions, as CancelCombat does, no longer ends the
 conversation it is i

---
 src/libs/game/action/conversation.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/libs/game/action/conversation.cpp b/src/libs/game/action/conversation.cpp
index 48c2a3f2d..118fa1a49 100644
--- a/src/libs/game/action/conversation.cpp
+++ b/src/libs/game/action/conversation.cpp
@@ -184,6 +184,11 @@ void StartConversationAction::admit() {
 }
 
 bool StartConversationAction::cancel(std::shared_ptr<Action> self, Object &actor) {
+    // A request that has started its conversation is done: clearing it, as a
+    // script of the opening entry may, leaves the conversation running.
+    if (isCompleted()) {
+        return true;
+    }
     // A dropped or failed request ends the conversation being under way.
     _game.setDialogUnderWay(false);
     _game.globalFade().finishDialog(_fadeDialog);
@@ -317,11 +322,14 @@ void StartConversationAction::execute(std::shared_ptr<Action> self, Object &acto
         return;
     }
 
+    // The request is done before its conversation starts, and the
+    // conversation owns the admission from then on: the opening entry's
+    // scripts run inside the start, and may clear this request.
     const auto listener = dialogOwner == actorPtr ? _objectToConverse : actorPtr;
-    _game.startDialog(dialogOwner, _dialogResRef.empty() ? dialogOwner->conversation() : _dialogResRef,
-                      _fadeDialog, listener);
-    _fadeDialog.reset(); // successful startup is now owned by Conversation
+    auto admission = std::move(_fadeDialog);
     complete();
+    _game.startDialog(dialogOwner, _dialogResRef.empty() ? dialogOwner->conversation() : _dialogResRef,
+                      std::move(admission), listener);
 }
 
 // A conversation names its dialog by a resource name of at most sixteen

From 3679f6e04f6b84c29b4ed96cd3964dbeafc097a3 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:06:18 -0400
Subject: [PATCH 22/23] Fix the Endar Spire duel, door visibility and saved
 placed objects

- A duel partner acts as soon as its master's hold ends, and a spent
  attack ends with its own round, so both duellists keep fighting.
- Time out of focus is not counted when the window returns, so combat
  timers no longer all expire at once.
- A room without a walkmesh claims no object, so doors next to such
  rooms are no longer hidden.
- Sight is blocked by every room's walls and every closed door, so
  objects across the map can no longer be targeted.
- Placed doors, placeables and other objects are saved with their
  blueprint, so a loaded game keeps their scripts, appearance and names.
---
 include/reone/game/combat.h           |  6 +++--
 include/reone/game/game.h             |  5 ++++
 include/reone/game/object.h           |  6 +++++
 include/reone/game/room.h             |  3 ++-
 src/apps/engine/engine.cpp            |  7 +++++
 src/libs/game/action/attackobject.cpp |  6 +++--
 src/libs/game/action/usefeat.cpp      |  6 +++--
 src/libs/game/combat.cpp              | 13 +++++++++-
 src/libs/game/object.cpp              |  8 ++++++
 src/libs/game/object/area.cpp         | 37 ++++++++++++++++++++++-----
 src/libs/game/object/door.cpp         |  1 +
 src/libs/game/object/encounter.cpp    |  1 +
 src/libs/game/object/placeable.cpp    |  1 +
 src/libs/game/object/sound.cpp        |  1 +
 src/libs/game/object/store.cpp        |  1 +
 src/libs/game/object/trigger.cpp      |  1 +
 src/libs/game/object/waypoint.cpp     |  1 +
 src/libs/game/room.cpp                |  7 +++++
 18 files changed, 97 insertions(+), 14 deletions(-)

diff --git a/include/reone/game/combat.h b/include/reone/game/combat.h
index edd9980c0..c885ddb55 100644
--- a/include/reone/game/combat.h
+++ b/include/reone/game/combat.h
@@ -304,8 +304,8 @@ class Combat {
      * round: a round the partner began, or one of its own, ends. A round the
      * two share starts again from the beginning for both; a partner whose
      * round was its own gets a side, with no command yet, in the attacker's
-     * round, held for the attack's pause. An engaged partner owning no round
-     * is held for the attack's pause.
+     * round, held for the attack's pause and free to act as soon as that hold
+     * ends. An engaged partner owning no round is held for the attack's pause.
      */
     bool engagePhysicalTarget(const Creature &attacker, Object &target, int pauseMilliseconds);
     /** The round the action runs in is engaged. */
@@ -319,6 +319,8 @@ class Combat {
     bool awaitsRoundEnd(const Creature &actor, std::optional<std::reference_wrapper<const Action>> self) const;
     /** Whether the creature has a command in a round that has not ended. */
     bool ownsRound(const Creature &actor) const;
+    /** The action carries out its creature's side of a round that has not ended. */
+    bool runsRound(const Action &action) const;
     /** The creature owns a round that no action still waiting in its queue belongs to. */
     bool ownsDetachedRound(const Creature &actor) const;
     /** The creature takes part in an engaged (paired) round. */
diff --git a/include/reone/game/game.h b/include/reone/game/game.h
index 7d3419902..6e27e28c7 100644
--- a/include/reone/game/game.h
+++ b/include/reone/game/game.h
@@ -259,6 +259,11 @@ class Game : boost::noncopyable {
      * that one is due.
      */
     bool consumeTimingDiscontinuity();
+    /**
+     * The world waits while the window is out of focus: none of that time
+     * passes in it, and its clock takes up again from the next update.
+     */
+    void holdWorldClock() { _worldClockSample.reset(); }
 
     /**
      * Play a movie, ending any module transition movies.
diff --git a/include/reone/game/object.h b/include/reone/game/object.h
index cce99eb62..95b8b70ce 100644
--- a/include/reone/game/object.h
+++ b/include/reone/game/object.h
@@ -540,6 +540,12 @@ class Object : public scene::IUser, boost::noncopyable {
         const resource::Gff &gff,
         const SerializedIdentityContext &identityContext,
         SaveRecordOrigin origin = {});
+    /**
+     * Keep the record an object placed from a blueprint was made from: the
+     * blueprint's fields, with those the placement gives in their place. A
+     * save writes the object over it.
+     */
+    void captureAuthoredRecord(const resource::Gff &blueprint, const resource::Gff &placement);
     const std::optional<SaveRecordProvenance> &saveRecordProvenance() const {
         return _saveRecordProvenance;
     }
diff --git a/include/reone/game/room.h b/include/reone/game/room.h
index 8f53b8c66..9963f2972 100644
--- a/include/reone/game/room.h
+++ b/include/reone/game/room.h
@@ -52,7 +52,8 @@ class Room : public scene::IUser {
     /**
      * Whether the room's box holds a point seen from above, edges included.
      * The box spans the room's meshes, but for animated meshes and background
-     * geometry; a room without such a mesh holds no point.
+     * geometry; a room without such a mesh, or whose model has no walkmesh,
+     * holds no point.
      */
     bool boxHolds(const glm::vec2 &point) const;
     /** The room's box (see boxHolds). */
diff --git a/src/apps/engine/engine.cpp b/src/apps/engine/engine.cpp
index a9f7e6331..c10c24a28 100644
--- a/src/apps/engine/engine.cpp
+++ b/src/apps/engine/engine.cpp
@@ -427,6 +427,13 @@ void Engine::processEvents(bool &quit) {
             imguiHandle(sdlEvent);
             continue;
         }
+        // While the window is out of focus the world waits. None of that time
+        // is charged to it: the frame clock and the world clock start again
+        // from the moment the window is back.
+        if (sdlEvent.type == SDL_EVENT_WINDOW_FOCUS_GAINED) {
+            _ticks = _services->system.clock.micros();
+            _game->holdWorldClock();
+        }
         if (_window->handle(sdlEvent)) {
             if (_window->isCloseRequested()) {
                 quit = true;
diff --git a/src/libs/game/action/attackobject.cpp b/src/libs/game/action/attackobject.cpp
index b74269aa3..63145e9ca 100644
--- a/src/libs/game/action/attackobject.cpp
+++ b/src/libs/game/action/attackobject.cpp
@@ -166,8 +166,10 @@ void AttackObjectAction::execute(std::shared_ptr<Action> self, Object &actor, fl
 
     attacker.setDesiredFacingToward(target->position());
 
-    // Once its round has been ended, a started attack has nothing left to do.
-    if ((_schedule.isMelee() || _schedule.isRanged()) && !_game.combat().ownsRound(attacker)) {
+    // Once its round has been ended, a started attack has nothing left to do,
+    // also when its creature has been given a new round meanwhile: the attack
+    // does not carry over into it.
+    if ((_schedule.isMelee() || _schedule.isRanged()) && !_game.combat().runsRound(*self)) {
         finish(attacker);
         return;
     }
diff --git a/src/libs/game/action/usefeat.cpp b/src/libs/game/action/usefeat.cpp
index 87d830e4f..240ae22db 100644
--- a/src/libs/game/action/usefeat.cpp
+++ b/src/libs/game/action/usefeat.cpp
@@ -100,8 +100,10 @@ void UseFeatAction::execute(std::shared_ptr<Action> self, Object &actor, float d
 
     attacker.setDesiredFacingToward(target->position());
 
-    // Once its round has been ended, a started attack has nothing left to do.
-    if ((_schedule.isMelee() || _schedule.isRanged()) && !_game.combat().ownsRound(attacker)) {
+    // Once its round has been ended, a started attack has nothing left to do,
+    // also when its creature has been given a new round meanwhile: the attack
+    // does not carry over into it.
+    if ((_schedule.isMelee() || _schedule.isRanged()) && !_game.combat().runsRound(*self)) {
         finish(attacker);
         return;
     }
diff --git a/src/libs/game/combat.cpp b/src/libs/game/combat.cpp
index 1709aa6ae..4d2b31765 100644
--- a/src/libs/game/combat.cpp
+++ b/src/libs/game/combat.cpp
@@ -556,6 +556,14 @@ bool Combat::ownsRound(const Creature &actor) const {
     });
 }
 
+bool Combat::runsRound(const Action &action) const {
+    return std::any_of(_rounds.begin(), _rounds.end(), [&action](const auto &round) {
+        return std::any_of(round->actions.begin(), round->actions.end(), [&action](const auto &entry) {
+            return entry.running() && (entry.action.get() == &action || &entry.action->combatAction() == &action);
+        });
+    });
+}
+
 bool Combat::ownsDetachedRound(const Creature &actor) const {
     const auto &nodes = actor.actions().nodes;
     bool owned = false;
@@ -2336,7 +2344,9 @@ bool Combat::engagePhysicalTarget(const Creature &attacker, Object &target, int
             endRound(*partner, 1);
             // The partner's round starts again on the attacker's side, with no
             // command yet, aimed at the attacker and held for the attack's
-            // pause; it runs out like any round.
+            // pause. The hold stands for the attacker's turn: once it ends,
+            // the partner may act at once, and its round runs out a full
+            // round later.
             if (round && round->actions.size() == 1) {
                 auto placeholder = _game.newAction<WaitAction>(0.0f);
                 placeholder->complete();
@@ -2345,6 +2355,7 @@ bool Combat::engagePhysicalTarget(const Creature &attacker, Object &target, int
                 round->actions.emplace_back(placeholder, live, master, false);
                 auto &side = round->actions.back();
                 side.slot = 1;
+                side.state = CombatRound::SecondAction;
                 side.pauseRemaining = pauseMilliseconds / 1000.0f;
                 side.pauseOwner = master;
                 round->duel = true;
diff --git a/src/libs/game/object.cpp b/src/libs/game/object.cpp
index 9d88e9db2..ba9b9e97f 100644
--- a/src/libs/game/object.cpp
+++ b/src/libs/game/object.cpp
@@ -623,6 +623,14 @@ void Object::captureSaveRecord(
         SaveGffShadow::capture(gff), std::move(origin), std::move(identity)};
 }
 
+void Object::captureAuthoredRecord(const resource::Gff &blueprint, const resource::Gff &placement) {
+    auto record = blueprint.deepCopy();
+    for (const auto &field : placement.fields()) {
+        replaceSaveField(*record, field.deepCopy());
+    }
+    _saveRecordProvenance = SaveRecordProvenance {SaveGffShadow::capture(*record), SaveRecordOrigin {}, std::nullopt};
+}
+
 void Object::assignSerializedObjectIdentity(
     const SerializedObjectIdentity &identity) {
     if (_saveRecordProvenance) {
diff --git a/src/libs/game/object/area.cpp b/src/libs/game/object/area.cpp
index df55eebb5..a0c47a5b2 100644
--- a/src/libs/game/object/area.cpp
+++ b/src/libs/game/object/area.cpp
@@ -104,6 +104,14 @@ static constexpr float kSharedObstacleThickness2 = 0.16f;
 static constexpr int kSoundDetourPenalty = 2;
 static constexpr int kSoundWallPenaltyPerMetre = 5;
 static constexpr float kLineOfSightHeight = 1.7f;        // TODO: make it appearance-based
+// Every surface material, for lines that any face stops.
+static const std::set<uint32_t> kEverySurface = [] {
+    std::set<uint32_t> materials;
+    for (uint32_t material = 0; material < Walkmesh::kSurfaceMaterialCount; ++material) {
+        materials.insert(material);
+    }
+    return materials;
+}();
 
 static constexpr float kMaxCollisionDistance = 8.0f;
 static constexpr float kMaxCollisionDistance2 = kMaxCollisionDistance * kMaxCollisionDistance;
@@ -2768,6 +2776,10 @@ bool Area::findCreatureCollision(
     return found;
 }
 
+// The line of sight runs between the two at eye height. The walls and floors
+// of every room stop it, whatever their material, and so does every closed
+// door but the one looked at, however far away. Open doors, placeables and
+// creatures do not.
 bool Area::isObjectSeen(const Creature &subject, const Object &object) const {
     if (!object.visible()) {
         return false;
@@ -2777,18 +2789,31 @@ bool Area::isObjectSeen(const Creature &subject, const Object &object) const {
         return false;
     }
 
-    auto &sceneGraph = _services.scene.graphs.get(_sceneName);
-
     glm::vec3 origin(subject.position());
     origin.z += kLineOfSightHeight;
 
     glm::vec3 dest(object.position());
     dest.z += kLineOfSightHeight;
 
-    Collision collision;
-    if (sceneGraph.testLineOfSight(origin, dest, collision)) {
-        return collision.user == &object ||
-               subject.getSquareDistanceTo(object) < glm::distance2(origin, collision.intersection);
+    const float length = glm::distance(origin, dest);
+    const glm::vec3 dir {(dest - origin) / length};
+
+    for (const auto &room : _rooms) {
+        const auto &walkmesh = room.second->walkmesh();
+        if (walkmesh && !walkmesh->walkmesh().raycast(kEverySurface, origin, dir, length, /*ignoreBackface=*/false).fail) {
+            return false;
+        }
+    }
+    for (const auto &candidate : _objectsByType.at(ObjectType::Door)) {
+        const auto &walkmesh = static_cast<const Door &>(*candidate).walkmeshClosed();
+        if (candidate.get() == &object || !walkmesh || !walkmesh->isEnabled()) {
+            continue;
+        }
+        const glm::vec3 originLocal {walkmesh->absoluteTransformInverse() * glm::vec4(origin, 1.0f)};
+        const glm::vec3 dirLocal {walkmesh->absoluteTransformInverse() * glm::vec4(dir, 0.0f)};
+        if (!walkmesh->walkmesh().raycast(kEverySurface, originLocal, dirLocal, length, /*ignoreBackface=*/false).fail) {
+            return false;
+        }
     }
 
     return true;
diff --git a/src/libs/game/object/door.cpp b/src/libs/game/object/door.cpp
index 7baa680fd..183bd7373 100644
--- a/src/libs/game/object/door.cpp
+++ b/src/libs/game/object/door.cpp
@@ -74,6 +74,7 @@ void Door::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto utd = _services.resource.gffs.get(templateRes, ResType::Utd)) {
             deserializeAll(*utd, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*utd, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/encounter.cpp b/src/libs/game/object/encounter.cpp
index 9f5a6b3b5..c7257a11a 100644
--- a/src/libs/game/object/encounter.cpp
+++ b/src/libs/game/object/encounter.cpp
@@ -51,6 +51,7 @@ void Encounter::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto ute = _services.resource.gffs.get(templateRes, ResType::Ute)) {
             deserializeAll(*ute, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*ute, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/placeable.cpp b/src/libs/game/object/placeable.cpp
index 6b42af653..d979ae1d9 100644
--- a/src/libs/game/object/placeable.cpp
+++ b/src/libs/game/object/placeable.cpp
@@ -91,6 +91,7 @@ void Placeable::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto utp = _services.resource.gffs.get(templateRes, ResType::Utp)) {
             deserializeAll(*utp, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*utp, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/sound.cpp b/src/libs/game/object/sound.cpp
index 042eb00c9..d74985119 100644
--- a/src/libs/game/object/sound.cpp
+++ b/src/libs/game/object/sound.cpp
@@ -51,6 +51,7 @@ void Sound::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto uts = _services.resource.gffs.get(templateRes, ResType::Uts)) {
             deserializeAll(*uts, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*uts, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/store.cpp b/src/libs/game/object/store.cpp
index 3c65a18b7..61dfb7e28 100644
--- a/src/libs/game/object/store.cpp
+++ b/src/libs/game/object/store.cpp
@@ -46,6 +46,7 @@ void Store::deserialize(
         gff.readResRef(templateRes, "ResRef")) {
         if (auto utm = _services.resource.gffs.get(templateRes, ResType::Utm)) {
             deserializeAll(*utm, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*utm, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/trigger.cpp b/src/libs/game/object/trigger.cpp
index 58e77197b..ffbe0360f 100644
--- a/src/libs/game/object/trigger.cpp
+++ b/src/libs/game/object/trigger.cpp
@@ -97,6 +97,7 @@ void Trigger::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto utt = _services.resource.gffs.get(templateRes, ResType::Utt)) {
             deserializeAll(*utt, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*utt, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/object/waypoint.cpp b/src/libs/game/object/waypoint.cpp
index d8c7e3b02..14fd2f63b 100644
--- a/src/libs/game/object/waypoint.cpp
+++ b/src/libs/game/object/waypoint.cpp
@@ -48,6 +48,7 @@ void Waypoint::deserialize(
         gff.readResRef(templateRes, "TemplateResRef")) {
         if (auto utw = _services.resource.gffs.get(templateRes, ResType::Utw)) {
             deserializeAll(*utw, SerializedIdentityContext::templateResource(templateRes));
+            captureAuthoredRecord(*utw, gff);
         }
     }
     deserializeAll(gff, identityContext);
diff --git a/src/libs/game/room.cpp b/src/libs/game/room.cpp
index 1fad44304..8dcf65be1 100644
--- a/src/libs/game/room.cpp
+++ b/src/libs/game/room.cpp
@@ -49,6 +49,7 @@ void Room::computeBox() {
     if (!_model) {
         return;
     }
+    bool walkable = false;
     std::stack<std::reference_wrapper<const ModelNode>> nodes;
     nodes.push(*_model->model().rootNode());
     while (!nodes.empty()) {
@@ -60,6 +61,7 @@ void Room::computeBox() {
         if (!node.isMesh() || (node.flags() & MdlNodeFlags::anim) != 0) {
             continue;
         }
+        walkable = walkable || node.isAABBMesh();
         if (node.mesh()->backgroundGeometry) {
             _backgroundGeometry = true;
             continue;
@@ -70,6 +72,11 @@ void Room::computeBox() {
             _boxMax = glm::max(_boxMax, point);
         }
     }
+    // A room whose model has no walkmesh holds no point.
+    if (!walkable) {
+        _boxMin = kEmptyBoxMin;
+        _boxMax = kEmptyBoxMax;
+    }
 }
 
 void Room::setVisible(bool visible) {

From bce8cb56b811d418c09f701e88507520bb41bff5 Mon Sep 17 00:00:00 2001
From: Vriff <74007411+vrifftech@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:46:13 -0400
Subject: [PATCH 23/23] Adding instruction limit to script execution

---
 include/reone/game/script/runner.h      | 14 ++++++++++++++
 include/reone/script/executioncontext.h |  6 ++++++
 src/libs/game/script/runner.cpp         | 15 +++++++++++++--
 src/libs/script/virtualmachine.cpp      | 11 +++++++++++
 4 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/include/reone/game/script/runner.h b/include/reone/game/script/runner.h
index 4845467c4..93e624916 100644
--- a/include/reone/game/script/runner.h
+++ b/include/reone/game/script/runner.h
@@ -24,7 +24,10 @@ namespace reone {
 
 namespace script {
 
+struct ExecutionContext;
+
 class IRoutines;
+class ScriptProgram;
 
 }
 
@@ -67,6 +70,17 @@ class ScriptRunner {
 private:
     script::IRoutines &_routines;
     resource::IScripts &_scripts;
+
+    /** The instruction count of the outermost run, shared by the runs it starts. */
+    std::shared_ptr<int> _instructionsRun;
+    /** How many runs are under way, one inside another. */
+    int _runDepth {0};
+
+    /**
+     * Runs a program. A run started while another is under way shares its
+     * instruction count; an outermost run starts a new one.
+     */
+    int runProgram(std::shared_ptr<script::ScriptProgram> program, std::unique_ptr<script::ExecutionContext> ctx);
 };
 
 } // namespace game
diff --git a/include/reone/script/executioncontext.h b/include/reone/script/executioncontext.h
index 9cafd56d9..a992d7072 100644
--- a/include/reone/script/executioncontext.h
+++ b/include/reone/script/executioncontext.h
@@ -34,6 +34,12 @@ struct ExecutionContext {
 
     std::vector<Argument> args;
 
+    /**
+     * The instructions run so far by this run and by the runs it started,
+     * which share the count; a run given none counts its own.
+     */
+    std::shared_ptr<int> instructionsRun;
+
     /// Find an argument variable or return nullptr.
     ///
     /// Arguments are specific to a script run. For example, LastOpenedBy
diff --git a/src/libs/game/script/runner.cpp b/src/libs/game/script/runner.cpp
index 597c44652..1f2986c1f 100644
--- a/src/libs/game/script/runner.cpp
+++ b/src/libs/game/script/runner.cpp
@@ -40,7 +40,7 @@ int ScriptRunner::run(const std::string &resRef, const std::vector<Argument> &ar
     ctx->routines = &_routines;
     ctx->args = args;
 
-    return VirtualMachine(program, std::move(ctx)).run();
+    return runProgram(program, std::move(ctx));
 }
 
 int ScriptRunner::run(const std::string &resRef, uint32_t callerId) {
@@ -67,7 +67,18 @@ int ScriptRunner::run(
     ctx->routines = &_routines;
     ctx->args = args;
     ctx->savedState = std::make_shared<ExecutionState>(*continuation._state);
-    return VirtualMachine(continuation._state->program, std::move(ctx)).run();
+    return runProgram(continuation._state->program, std::move(ctx));
+}
+
+int ScriptRunner::runProgram(std::shared_ptr<ScriptProgram> program, std::unique_ptr<ExecutionContext> ctx) {
+    if (_runDepth == 0) {
+        _instructionsRun = std::make_shared<int>(0);
+    }
+    ctx->instructionsRun = _instructionsRun;
+    ++_runDepth;
+    const int result = VirtualMachine(std::move(program), std::move(ctx)).run();
+    --_runDepth;
+    return result;
 }
 
 int ScriptRunner::run(
diff --git a/src/libs/script/virtualmachine.cpp b/src/libs/script/virtualmachine.cpp
index 28d24a2cd..1ceb6b905 100644
--- a/src/libs/script/virtualmachine.cpp
+++ b/src/libs/script/virtualmachine.cpp
@@ -31,6 +31,9 @@ namespace reone {
 namespace script {
 
 static constexpr int kStartInstructionOffset = 13;
+// A run stops before its next instruction once it has run this many,
+// counting those of the runs it started.
+static constexpr int kMaxInstructionsPerRun = 131071;
 static constexpr float kFloatTolerance = 1e-5;
 
 VirtualMachine::VirtualMachine(std::shared_ptr<ScriptProgram> program, std::unique_ptr<ExecutionContext> context) :
@@ -225,7 +228,15 @@ int VirtualMachine::run() {
         debug(ss.str());
     }
 
+    if (!_context->instructionsRun) {
+        _context->instructionsRun = std::make_shared<int>(0);
+    }
     while (insOff < _program->length()) {
+        if (++*_context->instructionsRun > kMaxInstructionsPerRun) {
+            error(str(boost::format("Script '%s' stopped at %04x: too many instructions") % _program->name() % insOff),
+                  LogChannel::Script);
+            return -1;
+        }
         const Instruction &ins = _program->getInstruction(insOff);
         auto handler = _handlers.find(ins.type);