Removed the ability to step in a yielded thread.

Changed the way the thread select widget works to make the thread status text update properly.

src/quest_editor/QuestRunner.ts

@@ -70,10 +70,8 @@ export class QuestRunner {
     private readonly _breakpoints: WritableListProperty<Breakpoint> = list_property();
     private readonly _pause_location: WritableProperty<number | undefined> = property(undefined);
     private readonly _thread_ids: WritableListProperty<number> = list_property();
-    private readonly _debugging_thread_id: WritableProperty<number | undefined> = property(
-        undefined,
-    );
     private readonly _active_thread_id: WritableProperty<number | undefined> = property(undefined);
+    private readonly _shown_thread_id: WritableProperty<number | undefined> = property(undefined);
 
     private readonly debugger: Debugger;
 
@@ -96,8 +94,8 @@ export class QuestRunner {
     readonly breakpoints: ListProperty<Breakpoint> = this._breakpoints;
     readonly pause_location: Property<number | undefined> = this._pause_location;
     readonly thread_ids: ListProperty<number> = this._thread_ids;
-    readonly debugging_thread_id: Property<number | undefined> = this._debugging_thread_id;
     readonly active_thread_id: Property<number | undefined> = this._active_thread_id;
+    readonly shown_thread_id: Property<number | undefined> = this._shown_thread_id;
 
     get game_state(): GameState {
         return this._game_state;
@@ -171,8 +169,8 @@ export class QuestRunner {
         this.debugger.deactivate_breakpoints();
         this._state.val = QuestRunnerState.Stopped;
         this._pause_location.val = undefined;
-        this._debugging_thread_id.val = undefined;
         this._active_thread_id.val = undefined;
+        this._shown_thread_id.val = undefined;
         this._thread_ids.clear();
         this.npcs.splice(0, this.npcs.length);
         this.objects.splice(0, this.objects.length);
@@ -207,26 +205,20 @@ export class QuestRunner {
         this._breakpoints.splice(0, Infinity, ...this.debugger.breakpoints);
     }
 
-    set_debugging_thread(thread_id: number): void {
+    show_thread_location(thread_id: number): void {
-        if (
+        // Update highlight location.
-            thread_id !== this.debugging_thread_id.val &&
-            this.thread_ids.val.indexOf(thread_id) > -1
-        ) {
-            // Update pause location.
         const ip = this.vm.get_instruction_pointer(thread_id);
 
         // Exists in source?
         if (ip && ip.source_location) {
-                this._debugging_thread_id.val = thread_id;
-                this.vm.set_debugging_thread(thread_id);
             this._pause_location.val = ip.source_location.line_no;
+            this._shown_thread_id.val = thread_id;
         } else {
             this.logger.warn(
                 `Failed to select thread #${thread_id} because its execution location is unknown.`,
             );
         }
     }
-    }
 
     private schedule_frame(): void {
         if (this.animation_frame == undefined) {
@@ -295,8 +287,9 @@ export class QuestRunner {
     };
 
     private update_thread_info(): void {
-        this._debugging_thread_id.val = this.vm.get_debugging_thread_id();
+        const thread_id = this.vm.get_current_thread_id();
-        this._active_thread_id.val = this.vm.get_current_thread_id();
+        this._active_thread_id.val = thread_id;
+        this._shown_thread_id.val = thread_id;
         this._thread_ids.splice(0, this._thread_ids.length.val, ...this.vm.get_thread_ids());
     }
 

src/quest_editor/controllers/DebugController.ts

@@ -6,14 +6,19 @@ import { GuiStore, GuiTool } from "../../core/stores/GuiStore";
 import { LogEntry } from "../../core/Logger";
 import { LogStore } from "../stores/LogStore";
 import { Severity } from "../../core/Severity";
+import { map } from "../../core/observable";
+
+type ThreadIdAndLabel = {
+    id: number;
+    label: string;
+};
 
 export class DebugController extends Controller {
     readonly can_debug: Property<boolean>;
     readonly can_step: Property<boolean>;
     readonly can_stop: Property<boolean>;
-    readonly thread_ids: ListProperty<number>;
+    readonly threads: Property<ThreadIdAndLabel[]>;
-    readonly debugging_thread_id: Property<number | undefined>;
+    readonly selected_thread_id: Property<ThreadIdAndLabel>;
-    readonly active_thread_id: Property<number | undefined>;
     readonly can_select_thread: Property<boolean>;
     readonly log: ListProperty<LogEntry>;
     readonly severity: Property<Severity>;
@@ -31,11 +36,24 @@ export class DebugController extends Controller {
 
         this.can_stop = quest_editor_store.quest_runner.running;
 
-        this.thread_ids = quest_editor_store.quest_runner.thread_ids;
+        this.threads = map(
+            (thread_ids, active_thread_id) =>
+                thread_ids.map(id => {
+                    const status = active_thread_id === id ? "Active" : "Yielded";
+                    return {
+                        id,
+                        label: `Thread #${id} (${status})`,
+                    };
+                }),
+            quest_editor_store.quest_runner.thread_ids,
+            quest_editor_store.quest_runner.active_thread_id,
+        );
 
-        this.debugging_thread_id = quest_editor_store.quest_runner.debugging_thread_id;
+        this.selected_thread_id = map(
-
+            (threads, shown_thread_id) => threads.find(thread => thread.id === shown_thread_id)!,
-        this.active_thread_id = quest_editor_store.quest_runner.active_thread_id;
+            this.threads,
+            quest_editor_store.quest_runner.shown_thread_id,
+        );
 
         this.can_select_thread = quest_editor_store.quest_runner.thread_ids.map(
             ids => ids.length > 0 && quest_editor_store.quest_runner.running.val,
@@ -92,6 +110,6 @@ export class DebugController extends Controller {
     };
 
     select_thread = (thread_id: number): void => {
-        this.quest_editor_store.quest_runner.set_debugging_thread(thread_id);
+        this.quest_editor_store.quest_runner.show_thread_location(thread_id);
     };
 }

src/quest_editor/gui/DebugView.ts

@@ -49,15 +49,12 @@ export class DebugView extends ResizableView {
             icon_left: Icon.Stop,
             tooltip: "Stop execution (Shift-F5)",
         });
-        // TODO: ensure label is up-to-date.
         const thread_select = new Select({
             class: "quest_editor_DebugView_thread_select",
             label: "Thread:",
-            items: ctrl.thread_ids,
+            items: ctrl.threads,
-            to_label: id => {
+            selected: ctrl.selected_thread_id,
-                const status = ctrl.active_thread_id.val === id ? "Active" : "Yielded";
+            to_label: id_and_label => id_and_label.label,
-                return `Thread #${id} (${status})`;
-            },
         });
         const severity_select = new Select({
             class: "quest_editor_DebugView_severity_select",
@@ -122,8 +119,7 @@ export class DebugView extends ResizableView {
             stop_button.onclick.observe(ctrl.stop),
             stop_button.enabled.bind_to(ctrl.can_stop),
 
-            thread_select.selected.observe(({ value }) => ctrl.select_thread(value!)),
+            thread_select.selected.observe(({ value }) => ctrl.select_thread(value!.id)),
-            thread_select.selected.bind_to(ctrl.debugging_thread_id),
             thread_select.enabled.bind_to(ctrl.can_select_thread),
 
             severity_select.selected.observe(

src/quest_editor/scripting/vm/VirtualMachine.ts

@@ -188,7 +188,6 @@ export class VirtualMachine {
 
     private readonly breakpoints: InstructionPointer[] = [];
     private paused = false;
-    private debugging_thread_id: number | undefined = undefined;
 
     /**
      * Set of unsupported opcodes that have already been logged. Each unsupported opcode will only
@@ -206,7 +205,7 @@ export class VirtualMachine {
 
     set step_mode(step_mode: StepMode) {
         if (step_mode != undefined) {
-            const thread = this.threads.find(thread => thread.id === this.debugging_thread_id);
+            const thread = this.current_thread();
 
             if (thread) {
                 thread.step_mode = step_mode;
@@ -262,15 +261,9 @@ export class VirtualMachine {
             );
         }
 
-        const thread = new Thread(
+        this.threads.push(
-            this.io,
+            new Thread(this.io, new InstructionPointer(seg_idx!, 0, this.object_code), area_id),
-            new InstructionPointer(seg_idx!, 0, this.object_code),
-            area_id,
         );
-        if (this.debugging_thread_id === undefined) {
-            this.debugging_thread_id = thread.id;
-        }
-        this.threads.push(thread);
     }
 
     /**
@@ -296,19 +289,9 @@ export class VirtualMachine {
                 const thread = this.current_thread();
 
                 if (!thread) {
-                    this.ignore_pauses_until_after_line = undefined;
                     return ExecutionResult.Suspended;
                 }
 
-                // This thread is the one currently selected for debugging?
-                const debugging_current_thread = thread.id === this.debugging_thread_id;
-
-                const allow_pausing = debugging_current_thread
-                    ? // Debugging current thread: Allow pausing if not ignoring pauses.
-                      this.ignore_pauses_until_after_line === undefined
-                    : // Not debugging current thread: Only allow pausing on breakpoints.
-                      thread.step_mode === StepMode.BreakPoint;
-
                 // Get current instruction.
                 const frame = thread.current_stack_frame()!;
                 inst_ptr = frame.instruction_pointer;
@@ -316,15 +299,11 @@ export class VirtualMachine {
 
                 // Check whether the VM needs to pause only if it's not already paused. In that case
                 // it's resuming.
-                if (allow_pausing && !this.paused) {
+                if (!this.paused) {
                     switch (thread.step_mode) {
                         case StepMode.BreakPoint:
                             if (this.breakpoints.findIndex(bp => bp.equals(inst_ptr!)) !== -1) {
                                 this.paused = true;
-                                // A breakpoint should interrupt the pause ignoring process
-                                // since we are now in a different execution location.
-                                this.debugging_thread_id = thread.id;
-                                this.ignore_pauses_until_after_line = undefined;
                                 return ExecutionResult.Paused;
                             }
                             break;
@@ -360,15 +339,6 @@ export class VirtualMachine {
                     }
                 }
 
-                // Check if we can stop ignoring pauses.
-                if (debugging_current_thread && this.ignore_pauses_until_after_line !== undefined) {
-                    const line = inst.asm?.mnemonic?.line_no;
-                    // Reached line, allow pausing again.
-                    if (this.ignore_pauses_until_after_line === line) {
-                        this.ignore_pauses_until_after_line = undefined;
-                    }
-                }
-
                 // Not paused, the next instruction can be executed.
                 this.paused = false;
 
@@ -427,9 +397,7 @@ export class VirtualMachine {
             this._halted = true;
             this.paused = false;
             this.breakpoints.splice(0, Infinity);
-            this.debugging_thread_id = undefined;
             this.unsupported_opcodes_logged.clear();
-            this.ignore_pauses_until_after_line = undefined;
             Thread.reset_id_counter();
         }
     }
@@ -477,35 +445,6 @@ export class VirtualMachine {
         }
     }
 
-    set_debugging_thread(thread_id: number): void {
-        if (this.threads.find(thread => thread.id === thread_id)) {
-            this.debugging_thread_id = thread_id;
-
-            const ip = this.get_instruction_pointer(thread_id);
-
-            if (thread_id === this.current_thread()?.id) {
-                this.ignore_pauses_until_after_line = undefined;
-            }
-            // If switching away from the thread that is currently being executed
-            // it will look like we are paused but actually the VM has not yet
-            // processed the next instruction and is not yet actually paused.
-            // We shall ignore the next pause to prevent the user from having
-            // to press the step button twice.
-            else {
-                // Exists in source?
-                if (ip && ip.source_location) {
-                    this.ignore_pauses_until_after_line = ip.source_location.line_no;
-                } else {
-                    this.ignore_pauses_until_after_line = undefined;
-                }
-            }
-        }
-    }
-
-    get_debugging_thread_id(): number | undefined {
-        return this.debugging_thread_id;
-    }
-
     get_thread_ids(): number[] {
         return this.threads.map(thread => thread.id);
     }
@@ -523,14 +462,6 @@ export class VirtualMachine {
 
         this.threads.splice(thread_idx, 1);
 
-        if (thread.id === this.debugging_thread_id) {
-            if (this.threads.length === 0) {
-                this.debugging_thread_id = undefined;
-            } else {
-                this.debugging_thread_id = this.threads[0].id;
-            }
-        }
-
         if (this.thread_idx >= thread_idx && this.thread_idx > 0) {
             this.thread_idx--;
         }