Allow script arrays to hold any value type, add script engine tests, archive old rpg code

Remove the per-array type category so arrays can mix types like structs.
Add 13 passing and 125 expected-failure duskscript test fixtures with a
table-driven runner. Also includes the in-progress entity/physics and
archive moves from the working tree.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>

test/duskscript/assets/pass_arrays.ds

@@ -0,0 +1,218 @@
+// Creating and reading
+var a = [1, 2, 3];
+assert(len(a) == 3);
+assert(a[0] == 1 && a[2] == 3);
+assert(len([]) == 0);
+var nested = [[1, 2], [3, [4, 5]]];
+assert(nested[1][1][0] == 4);
+assert(len(nested[1]) == 2);
+
+// Writing, assigning at the end appends
+a[1] = 20;
+assert(a[1] == 20);
+a[3] = 4;
+assert(len(a) == 4 && a[3] == 4);
+
+// push, pop, shift, unshift return and remove as expected
+var q = [];
+assert(push(q, "a") == 1);
+assert(push(q, "b") == 2);
+assert(unshift(q, "z") == 3);
+assert(q[0] == "z" && q[1] == "a" && q[2] == "b");
+assert(pop(q) == "b");
+assert(shift(q) == "z");
+assert(len(q) == 1 && q[0] == "a");
+assert(pop(q) == "a");
+assert(isundefined(pop(q)));
+assert(isundefined(shift(q)));
+assert(len(q) == 0);
+
+// insert, insertarr, splice
+var b = [1, 2, 5];
+assert(insert(b, 2, 3) == 4);
+assert(deepequal(b, [1, 2, 3, 5]));
+insert(b, 3, 4);
+assert(deepequal(b, [1, 2, 3, 4, 5]));
+insert(b, 0, 0);
+assert(deepequal(b, [0, 1, 2, 3, 4, 5]));
+insert(b, 6, 6);
+assert(deepequal(b, [0, 1, 2, 3, 4, 5, 6]));
+var c = [1, 4];
+assert(insertarr(c, 1, [2, 3]) == 4);
+assert(deepequal(c, [1, 2, 3, 4]));
+var d = [1, 2, 3, 4, 5];
+var removed = splice(d, 1, 2);
+assert(deepequal(removed, [2, 3]));
+assert(deepequal(d, [1, 4, 5]));
+removed = splice(d, 2);
+assert(deepequal(removed, [5]));
+assert(deepequal(d, [1, 4]));
+removed = splice(d, 0, 100);
+assert(deepequal(removed, [1, 4]));
+assert(len(d) == 0);
+removed = splice(d, 0, 0);
+assert(len(removed) == 0);
+
+// subarr copies a range
+var e = [10, 20, 30, 40];
+assert(deepequal(subarr(e, 1, 3), [20, 30]));
+assert(deepequal(subarr(e, 2), [30, 40]));
+assert(deepequal(subarr(e, 0, 0), []));
+assert(deepequal(subarr(e, 4), []));
+var slice = subarr(e, 0, 2);
+slice[0] = 99;
+assert(e[0] == 10);
+
+// indexof, lastindexof
+var f = [1, 2, 3, 2, 1];
+assert(indexof(f, 2) == 1);
+assert(lastindexof(f, 2) == 3);
+assert(indexof(f, 9) == -1);
+assert(lastindexof(f, 9) == -1);
+assert(indexof(["a", "b"], "b") == 1);
+assert(indexof([null, 1], null) == 0);
+
+// reverse and sort
+var g = [1, 2, 3, 4];
+reverse(g);
+assert(deepequal(g, [4, 3, 2, 1]));
+var odd = [1, 2, 3];
+reverse(odd);
+assert(deepequal(odd, [3, 2, 1]));
+reverse([]);
+var h = [3, 1, 2, 10, -5, 2.5];
+sort(h);
+assert(deepequal(h, [-5, 1, 2, 2.5, 3, 10]));
+sort(h, true);
+assert(deepequal(h, [10, 3, 2.5, 2, 1, -5]));
+var words = ["banana", "Apple", "cherry", "apple"];
+sort(words);
+assert(words[0] == "Apple" || words[0] == "apple");
+assert(words[3] == "cherry");
+assert(words[2] == "banana");
+var byLength = ["ccc", "a", "bb"];
+sort(byLength, false, function(x, y) { return len(x) - len(y); });
+assert(deepequal(byLength, ["a", "bb", "ccc"]));
+var one = [7];
+sort(one);
+assert(one[0] == 7);
+var emptySort = [];
+sort(emptySort);
+// sort is stable: equal keys keep their order
+var records = [{k: 1, n: "a"}, {k: 0, n: "b"}, {k: 1, n: "c"}, {k: 0, n: "d"}];
+sort(records, false, function(x, y) { return x.k - y.k; });
+assert(records[0].n == "b" && records[1].n == "d" && records[2].n == "a" && records[3].n == "c");
+// a long sort
+var big = [];
+for(var i = 0; i < 100; i++) push(big, (i * 37) % 101);
+sort(big);
+var ordered = true;
+for(var j = 1; j < len(big); j++) {
+  if(big[j - 1] > big[j]) ordered = false;
+}
+assert(ordered);
+
+// fill, merge, empty
+var filled = [];
+fill(filled, 7, 3);
+assert(deepequal(filled, [7, 7, 7]));
+fill(filled, "x", 1);
+assert(deepequal(filled, ["x"]));
+fill(filled, 0, 0);
+assert(len(filled) == 0);
+var m1 = [1, 2];
+assert(merge(m1, [3, 4]) == 4);
+assert(deepequal(m1, [1, 2, 3, 4]));
+merge(m1, []);
+assert(len(m1) == 4);
+merge(m1, m1);
+assert(len(m1) == 8);
+var toEmpty = [1, 2, 3];
+empty(toEmpty);
+assert(len(toEmpty) == 0);
+push(toEmpty, "fresh");
+assert(toEmpty[0] == "fresh");
+
+// filter, map, reduce
+var nums = [1, 2, 3, 4, 5, 6];
+var evens = clone(nums);
+filter(evens, function(v) { return v % 2 == 0; });
+assert(deepequal(evens, [2, 4, 6]));
+assert(len(nums) == 6);
+var withNulls = [1, null, 2, null];
+filter(withNulls);
+assert(deepequal(withNulls, [1, 2]));
+var indexes = clone(nums);
+filter(indexes, function(v, idx) { return idx < 2; });
+assert(deepequal(indexes, [1, 2]));
+assert(deepequal(map(nums, function(v) { return v * 10; }), [10, 20, 30, 40, 50, 60]));
+assert(deepequal(map(nums, function(v, idx) { return idx; }), [0, 1, 2, 3, 4, 5]));
+assert(len(map([], function(v) { return v; })) == 0);
+assert(reduce(nums, function(acc, v) { return acc + v; }, 0) == 21);
+assert(reduce(nums, function(acc, v) { return acc * v; }, 1) == 720);
+assert(reduce([], function(acc, v) { return acc + v; }, "start") == "start");
+assert(reduce(["a", "b"], function(acc, v) { return acc + v; }, "") == "ab");
+
+// flatten and join
+assert(deepequal(flatten([[1], [2, 3], []]), [1, 2, 3]));
+assert(len(flatten([])) == 0);
+assert(deepequal(flatten([[[1]], [2]]), [[1], 2]));
+assert(join([1, 2, 3], ", ") == "1, 2, 3");
+
+// Arrays are shared, clone is shallow, deepclone is not
+var original = [1, [2, 3]];
+var alias = original;
+alias[0] = 100;
+assert(original[0] == 100);
+var shallow = clone(original);
+shallow[0] = 5;
+assert(original[0] == 100);
+shallow[1][0] = 22;
+assert(original[1][0] == 22);
+var deep = deepclone(original);
+deep[1][0] = 33;
+assert(original[1][0] == 22);
+assert(deep[1][0] == 33);
+assert(deepequal(deepclone(original), original));
+assert(clone(original) != original);
+
+// deepequal
+assert(deepequal([], []));
+assert(deepequal([1, "a", [true, null]], [1, "a", [true, null]]));
+assert(!deepequal([1, 2], [1, 3]));
+assert(!deepequal([1, 2], [1, 2, 3]));
+assert(!deepequal([1], ["1"]));
+assert(deepequal(1, 1));
+assert(!deepequal(1, 2));
+assert(deepequal({a: 1, b: [1]}, {b: [1], a: 1}));
+assert(!deepequal({a: 1}, {a: 2}));
+assert(!deepequal({a: 1}, {b: 1}));
+assert(!deepequal([], {}));
+
+// Growing past the first capacity
+var grown = [];
+for(var n = 0; n < 200; n++) push(grown, n);
+assert(len(grown) == 200);
+assert(grown[0] == 0 && grown[199] == 199 && grown[100] == 100);
+var shrunk = 0;
+while(len(grown) > 0) {
+  pop(grown);
+  shrunk++;
+}
+assert(shrunk == 200);
+
+// Many shifts
+var queue = [];
+for(var k = 0; k < 50; k++) push(queue, k);
+var taken = 0;
+while(len(queue) > 0) {
+  assert(shift(queue) == taken);
+  taken++;
+}
+assert(taken == 50);
+
+// Looping while modifying a copy
+var source = [1, 2, 3];
+var copy = clone(source);
+foreach(var item : source) push(copy, item * 2);
+assert(deepequal(copy, [1, 2, 3, 2, 4, 6]));