Fixed a bug where you would have to press step multiple times to move to the next instruction when switching debugging threads.

src/quest_editor/QuestRunner.ts

@@ -60,6 +60,8 @@ export class QuestRunner {
     private readonly _state: WritableProperty<QuestRunnerState> = property(
         QuestRunnerState.Stopped,
     );
+    // Runner will ignore pauses until after this line number is hit.
+    private ignore_pauses_until_after_line: number | undefined = undefined;
 
     private initial_area_id = 0;
     private readonly npcs: QuestNpcModel[] = [];
@@ -170,6 +172,7 @@ export class QuestRunner {
         this.npcs.splice(0, this.npcs.length);
         this.objects.splice(0, this.objects.length);
         this._game_state = new GameStateInternal(Episode.I);
+        this.ignore_pauses_until_after_line = undefined;
     }
 
     /**
@@ -201,13 +204,40 @@ export class QuestRunner {
     }
 
     set_debugging_thread(thread_id: number): void {
-        if (this.thread_ids.val.indexOf(thread_id) > -1) {
+        if (
+            thread_id !== this.debugging_thread_id.val &&
+            this.thread_ids.val.indexOf(thread_id) > -1
+        ) {
             this._debugging_thread_id.val = thread_id;
             this.vm.set_debugging_thread(thread_id);
 
-            this._pause_location.val = this.vm.get_instruction_pointer(
+            // Update pause location.
-                this.debugging_thread_id.val,
+            const ip = this.vm.get_instruction_pointer(this.debugging_thread_id.val);
-            )?.source_location?.line_no;
+
+            // Exists in source?
+            if (ip && ip.source_location) {
+                this._pause_location.val = ip.source_location.line_no;
+
+                // If switching away from the thread that is currently being executed
+                // the VM will pause on the same instruction on the next step which
+                // would look strange to the user. Let's skip that pause to make it look normal.
+                if (thread_id !== this.vm.get_current_thread_id()) {
+                    this.ignore_pauses_until_after_line = ip.source_location.line_no;
+                } else {
+                    this.ignore_pauses_until_after_line = undefined;
+                }
+            }
+            // No source location. Belongs to another instruction?
+            else if (ip && ip.instruction.asm && ip.instruction.asm.args.length > 0) {
+                // Don't pause until after we hit the actual source location.
+                // This is because pausing on hidden instructions would look strange to the user.
+                this.ignore_pauses_until_after_line = this._pause_location.val =
+                    ip.instruction.asm.args[0].line_no;
+            }
+            // No source location can be inferred.
+            else {
+                this._pause_location.val = undefined;
+            }
         }
     }
 
@@ -233,12 +263,30 @@ export class QuestRunner {
             case ExecutionResult.Suspended:
                 this._state.val = QuestRunnerState.Running;
                 this.update_thread_info();
+                this.ignore_pauses_until_after_line = undefined;
                 break;
 
             case ExecutionResult.Paused:
-                this._state.val = QuestRunnerState.Paused;
+                {
-                pause_location = this.vm.get_instruction_pointer()?.source_location?.line_no;
+                    const line = this.vm.get_instruction_pointer()?.source_location?.line_no;
-                this.update_thread_info();
+
+                    // Pause.
+                    if (this.ignore_pauses_until_after_line === undefined) {
+                        this._state.val = QuestRunnerState.Paused;
+                        pause_location = line;
+                        this.update_thread_info();
+                    }
+                    // Ignore pause and keep running.
+                    else {
+                        // Allow pausing if reached line.
+                        if (this.ignore_pauses_until_after_line === line) {
+                            this.ignore_pauses_until_after_line = undefined;
+                        }
+
+                        this._state.val = QuestRunnerState.Running;
+                        this.schedule_frame();
+                    }
+                }
                 break;
 
             case ExecutionResult.WaitingVsync:

src/quest_editor/scripting/vm/VirtualMachine.ts

@@ -473,6 +473,10 @@ export class VirtualMachine {
         return this.threads.map(thread => thread.id);
     }
 
+    get_current_thread_id(): number | undefined {
+        return this.current_thread()?.id;
+    }
+
     private current_thread(): Thread | undefined {
         return this.threads[this.thread_idx];
     }