Merge remote-tracking branch 'github/master'

src/quest_editor/scripting/vm/index.test.ts

@@ -1,7 +1,12 @@
+/**
+ * @jest-environment jsdom
+ */
+
 import { VirtualMachine, ExecutionResult } from ".";
 import { VMIOStub } from "./VMIOStub";
 import { to_instructions } from "../../../../test/src/utils";
 import { Segment } from "../instructions";
+import { srand } from "./windows";
 
 test("integer arithmetic opcodes", () => {
     class TestIO extends VMIOStub {
@@ -158,3 +163,45 @@ test("basic window_msg output", () => {
     expect(io.winend).toBeCalledTimes(1);
     expect(io.error).toBeCalledTimes(0);
 });
+
+test("opcode get_random", () => {
+    const result_reg = 102;
+    const obj_code = to_instructions(`
+    .code
+    0:
+        leti r100, 0
+        leti r101, 65535
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+        get_random r100, r${result_reg}
+    `);
+
+    const vm = new VirtualMachine();
+    srand(123);
+    vm.load_object_code(obj_code);
+    vm.start_thread(0);
+
+    // run `let`s
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+
+    // test correct get_random sequence
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(879);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(38105);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(46149);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(26207);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(64725);
+    expect(vm.execute()).toBe(ExecutionResult.Ok);
+    expect(vm.get_register_unsigned(result_reg)).toBe(6529);
+    expect(vm.execute()).toBe(ExecutionResult.Halted);
+    expect(vm.get_register_unsigned(result_reg)).toBe(61497);
+});

src/quest_editor/scripting/vm/index.ts

@@ -79,6 +79,8 @@ import {
     OP_LETA,
     OP_FLET,
     OP_FLETI,
+    OP_GET_RANDOM,
+    OP_GETTIME,
 } from "../opcodes";
 import { VirtualMachineMemoryBuffer, VirtualMachineMemory } from "./memory";
 import {
@@ -92,6 +94,7 @@ import {
 } from "./utils";
 import { VirtualMachineIO } from "./io";
 import { VMIOStub } from "./VMIOStub";
+import { rand, srand, GetTickCount } from "./windows";
 
 const REGISTERS_BASE_ADDRESS = 0x00a954b0;
 const REGISTER_COUNT = 256;
@@ -101,7 +104,7 @@ const ARG_STACK_SLOT_SIZE = 4;
 const ARG_STACK_LENGTH = 8;
 const STRING_ARG_STORE_ADDRESS = 0x00a92700;
 const STRING_ARG_STORE_SIZE = 1024; // TODO: verify this value
-const FLOAT_EPSILON = 1.19e-07;
+const FLOAT_EPSILON = 1.19e-7;
 
 export enum ExecutionResult {
     Ok,
@@ -125,7 +128,9 @@ export class VirtualMachine {
     private thread_idx = 0;
     private window_msg_open = false;
 
-    constructor(private io: VirtualMachineIO = new VMIOStub()) {}
+    constructor(private io: VirtualMachineIO = new VMIOStub()) {
+        srand(GetTickCount());
+    }
 
     /**
      * Halts and resets the VM, then loads new object code.
@@ -541,12 +546,31 @@ export class VirtualMachine {
                     this.io.add_msg(str);
                 }
                 break;
+            case OP_GETTIME.code:
+                this.set_register_unsigned(arg0, Math.floor(Date.now() / 1000));
+                break;
             case OP_WINEND.code:
                 if (this.window_msg_open) {
                     this.window_msg_open = false;
                     this.io.winend();
                 }
                 break;
+            case OP_GET_RANDOM.code:
+                {
+                    const low = this.get_register_signed(arg0);
+                    const hi = this.get_register_signed(arg0 + 1);
+
+                    const r = rand();
+                    let result = Math.floor(Math.fround(r / 32768.0) * hi);
+
+                    // intentional. this is how the game does it.
+                    if (low >= result) {
+                        result = low;
+                    }
+
+                    this.set_register_signed(arg1, result);
+                }
+                break;
             default:
                 throw new Error(`Unsupported instruction: ${inst.opcode.mnemonic}.`);
         }
@@ -619,13 +643,13 @@ export class VirtualMachine {
     private set_register_word(reg: number, value: number): void {
         this.registers.write_u16_at(REGISTER_SIZE * reg, value);
     }
-    
+
     public get_register_byte(reg: number): number {
         return this.registers.u8_at(REGISTER_SIZE * reg);
     }
 
     public set_register_byte(reg: number, value: number): void {
-        this.registers.write_u8_at(REGISTER_SIZE * reg, value)
+        this.registers.write_u8_at(REGISTER_SIZE * reg, value);
     }
 
     public get_register_float(reg: number): number {

src/quest_editor/scripting/vm/windows.ts

@@ -0,0 +1,23 @@
+/**
+ * @file Implementations of some parts of the Win32 API and the MSVCRT C standard library.
+ */
+
+
+var holdrand = 1;
+
+export function srand(seed: number): void {
+    holdrand = seed;
+}
+
+export function rand(): number {
+    const r = (holdrand * 0x343fd + 0x269ec3) >>> 0;
+    holdrand = r;
+    return r >>> 0x10 & 0x7fff;
+}
+
+export function GetTickCount(): number {
+    // GetTickCount returns time elapsed since system start
+    // performance.now returns time elapsed since document load
+    // but both are monotonic so it's probably close enough?
+    return Math.floor(performance.now());
+}