Merge branch 'main' into p3-timeline-more-updates

Author: Legends0

.github/actions/setup-js-env/action.yml

@@ -5,7 +5,10 @@ runs:
   steps:
     - uses: actions/setup-node@v6
       with:
-        node-version: '>=24.18.0'
+        # 24.17 has a bug that breaks our workflows
+        # 26 introduces changes that break our workflows
+        # @TODO: remove upper restriction once dependencies no longer fail on 26
+        node-version: '>=24.18.0 <25'
         cache: 'npm'
         cache-dependency-path: 'package-lock.json'
 

resources/util.ts

@@ -264,16 +264,16 @@ const output16Dir: DirectionOutput16[] = [
 const outputCardinalDir: DirectionOutputCardinal[] = ['dirN', 'dirE', 'dirS', 'dirW'];
 const outputIntercardDir: DirectionOutputIntercard[] = ['dirNE', 'dirSE', 'dirSW', 'dirNW'];
 
-const compareDirectionOutput = (a: DirectionOutput16, b: DirectionOutput16): number => {
-  const getIndex = (n: DirectionOutput16) => {
-    const index = output16Dir.indexOf(n);
-    // Values outside of output16Dir (i.e. 'unknown') sort last
-    if (index < 0)
-      return output16Dir.length;
-    return index;
-  };
+const getDirectionIndex = (n: DirectionOutput16) => {
+  const index = output16Dir.indexOf(n);
+  // Values outside of output16Dir (i.e. 'unknown') sort last
+  if (index < 0)
+    return output16Dir.length;
+  return index;
+};
 
-  return getIndex(a) - getIndex(b);
+const compareDirectionOutput = (a: DirectionOutput16, b: DirectionOutput16): number => {
+  return getDirectionIndex(a) - getDirectionIndex(b);
 };
 
 const outputStrings16Dir: OutputStrings = {
@@ -356,6 +356,12 @@ const xyTo4DirIntercardNum = (x: number, y: number, centerX: number, centerY: nu
   return Math.round(2 - 2 * ((Math.PI / 4) + Math.atan2(x, y)) / Math.PI) % 4;
 };
 
+const xyToHeading = (x: number, y: number, centerX: number, centerY: number): number => {
+  x = x - centerX;
+  y = y - centerY;
+  return Math.atan2(x, y);
+};
+
 const hdgTo16DirNum = (heading: number): number => {
   // N = 0, NNE = 1, ..., NNW = 15
   return (Math.round(8 - 8 * heading / Math.PI) % 16 + 16) % 16;
@@ -371,6 +377,10 @@ const hdgTo4DirNum = (heading: number): number => {
   return (Math.round(2 - heading * 2 / Math.PI) % 4 + 4) % 4;
 };
 
+const outputFrom16DirNum = (dirNum: number): DirectionOutput16 => {
+  return output16Dir[dirNum] ?? 'unknown';
+};
+
 const outputFrom8DirNum = (dirNum: number): DirectionOutput8 => {
   return output8Dir[dirNum] ?? 'unknown';
 };
@@ -383,6 +393,88 @@ const outputFromIntercardNum = (dirNum: number): DirectionOutputIntercard => {
   return outputIntercardDir[dirNum] ?? 'unknown';
 };
 
+export type AnyDirection =
+  | DirectionOutputCardinal
+  | DirectionOutputIntercard
+  | DirectionOutput8
+  | DirectionOutput16;
+
+/**
+ * Get a function to pass to Array.sort to sort an array of DirectionOutput entries
+ *
+ * @example
+ * const dirs: DirectionOutputCardinal[] = ['dirN', 'dirW'];
+ *
+ * dirs.sort(getSortDirectionsClockwiseFunction('dirE'));
+ *
+ * // `dirs` should equal `['dirW', 'dirN']`
+ *
+ * @param from The DirectionOutput to treat as the start point for sort comparison
+ * @returns A function to pass to the Array.sort function
+ */
+export const getSortDirectionsClockwiseFunction = (
+  from?: AnyDirection,
+): (left: AnyDirection, right: AnyDirection) => number => {
+  // Default to dirN
+  let offset = 0;
+  if (from !== undefined && from !== 'unknown')
+    offset = getDirectionIndex(from);
+
+  const count = output16Dir.length;
+
+  return (left: AnyDirection, right: AnyDirection) => {
+    if (left === 'unknown' || right === 'unknown') {
+      return left === right ? 0 : left === 'unknown' ? 1 : -1;
+    }
+    const rightIndex = (count + getDirectionIndex(right) - offset) % count;
+    const leftIndex = (count + getDirectionIndex(left) - offset) % count;
+    return leftIndex - rightIndex;
+  };
+};
+
+type Point = {
+  x: number;
+  y: number;
+};
+
+/**
+ * Get a function to pass to Array.sort to sort an array of objects with `x` and `y` properties
+ *
+ * @example
+ * const points = [{ x: 101, y: 101 }, { x: 99, y: 99 }];
+ *
+ * points.sort(getSortPointsClockwiseFunction({x: 100, y: 100}, {x: 99, y: 101}));
+ *
+ * // `points` should now equal `[{ x: 99, y: 99 }, { x: 101, y: 101 }]`
+ *
+ * @param center The x/y point to treat as the center to calculate headings from
+ * @param reference The heading or x/y point to treat as the start point for sort comparison
+ * @returns A function to pass to the Array.sort function
+ */
+export const getSortPointsClockwiseFunction = <T extends Point>(
+  center: T,
+  reference: number | T = Math.PI, // Default to north
+): (left: T, right: T) => number => {
+  // Convert point to heading if needed
+  const offset = typeof reference === 'object'
+    ? xyToHeading(reference.x, reference.y, center.x, center.y)
+    : reference;
+
+  const twoPI = Math.PI * 2;
+
+  return (left: T, right: T) => {
+    // Get our base headings for the two points
+    const rightHeading = xyToHeading(right.x, right.y, center.x, center.y);
+    const leftHeading = xyToHeading(left.x, left.y, center.x, center.y);
+
+    // Adjust by reference offset
+    const rightHeadingOffset = (twoPI + (offset - rightHeading)) % twoPI;
+    const leftHeadingOffset = (twoPI + (offset - leftHeading)) % twoPI;
+
+    return leftHeadingOffset - rightHeadingOffset;
+  };
+};
+
 export const Directions = {
   output8Dir: output8Dir,
   output16Dir: output16Dir,
@@ -397,11 +489,14 @@ export const Directions = {
   xyTo16DirNum: xyTo16DirNum,
   xyTo8DirNum: xyTo8DirNum,
   xyTo4DirNum: xyTo4DirNum,
+  xyToHeading: xyToHeading,
   hdgTo16DirNum: hdgTo16DirNum,
   hdgTo8DirNum: hdgTo8DirNum,
   hdgTo4DirNum: hdgTo4DirNum,
+  outputFrom16DirNum: outputFrom16DirNum,
   outputFrom8DirNum: outputFrom8DirNum,
   outputFromCardinalNum: outputFromCardinalNum,
+  outputFromIntercardNum: outputFromIntercardNum,
   combatantStatePosTo8Dir: (
     combatant: PluginCombatantState,
     centerX: number,
@@ -452,6 +547,10 @@ export const Directions = {
     const dirNum = hdgTo8DirNum(heading);
     return outputFrom8DirNum(dirNum);
   },
+  xyTo16DirOutput: (x: number, y: number, centerX: number, centerY: number): DirectionOutput16 => {
+    const dirNum = xyTo16DirNum(x, y, centerX, centerY);
+    return outputFrom16DirNum(dirNum);
+  },
   xyTo8DirOutput: (x: number, y: number, centerX: number, centerY: number): DirectionOutput8 => {
     const dirNum = xyTo8DirNum(x, y, centerX, centerY);
     return outputFrom8DirNum(dirNum);

test/unittests/compile_test.ts

@@ -15,26 +15,20 @@ describe('compile test', () => {
   it('npm package should compile successfully', async function() {
     // eslint-disable-next-line @typescript-eslint/no-invalid-this
     this.timeout(30000); // allow a 30s timeout
-    let execError = false;
     let output = '';
+    let exitCode = -1;
     try {
       process.chdir(projectRoot);
       fs.rmSync('dist', { recursive: true, force: true });
-      await exec('npx tsc --declaration', [], {
+      exitCode = await exec('npx tsc --declaration', [], {
         listeners: {
           stdout: (data) => output += data.toString(),
-          stderr: (data) => {
-            execError = true;
-            output += data.toString();
-          },
+          stderr: (data) => output += data.toString(),
         },
       });
-      if (execError)
-        throw output;
     } catch (err) {
       console.error(err);
-      execError = true;
     }
-    assert(execError === false, output);
+    assert(exitCode === 0, output);
   });
 });

test/unittests/util_test.ts

@@ -2,9 +2,12 @@ import { assert } from 'chai';
 
 import Util, {
   allJobs,
+  AnyDirection,
   casterDpsJobs,
   craftingJobs,
   gatheringJobs,
+  getSortDirectionsClockwiseFunction,
+  getSortPointsClockwiseFunction,
   healerJobs,
   limitedJobs,
   meleeDpsJobs,
@@ -93,4 +96,97 @@ describe('util tests', () => {
       assert(!Util.isLimitedJob(job))
     );
   });
+
+  it('sorts directions clockwise from a reference direction and undefined reference', () => {
+    const dirs: AnyDirection[] = [
+      'dirNE',
+      'dirSW',
+      'dirN',
+      'dirNW',
+      'dirS',
+      'dirW',
+      'dirSE',
+      'dirE',
+    ];
+
+    let expected = ['dirNW', 'dirN', 'dirNE', 'dirE', 'dirSE', 'dirS', 'dirSW', 'dirW'];
+    let sorted = dirs.sort(getSortDirectionsClockwiseFunction('dirNW'));
+    assert.deepEqual(sorted, expected);
+
+    expected = ['dirN', 'dirNE', 'dirE', 'dirSE', 'dirS', 'dirSW', 'dirW', 'dirNW'];
+    sorted = dirs.sort(getSortDirectionsClockwiseFunction());
+    assert.deepEqual(sorted, expected);
+  });
+
+  it('sorts directions and unknowns, putting unknowns at the end', () => {
+    const dirs1: AnyDirection[] = [
+      'dirNE',
+      'unknown',
+      'dirN',
+      'unknown',
+      'dirNW',
+      'dirS',
+    ];
+
+    const expected1 = ['dirN', 'dirNE', 'dirS', 'dirNW', 'unknown', 'unknown'];
+    assert.deepEqual(dirs1.sort(getSortDirectionsClockwiseFunction()), expected1);
+
+    const dirs2: AnyDirection[] = ['dirNE', 'unknown', 'dirN', 'dirNW'];
+    const expected2 = ['dirNW', 'dirN', 'dirNE', 'unknown'];
+    assert.deepEqual(
+      dirs2.sort(getSortDirectionsClockwiseFunction('dirNW')),
+      expected2,
+    );
+  });
+
+  it('sorts points clockwise from a reference point', () => {
+    const getPoints = () => [
+      { id: 'NE', x: 1, y: -1 },
+      { id: 'SW', x: -1, y: 1 },
+      { id: 'N', x: 0, y: -1 },
+      { id: 'NW', x: -1, y: -1 },
+      { id: 'S', x: 0, y: 1 },
+      { id: 'W', x: -1, y: 0 },
+      { id: 'SE', x: 3, y: 3 },
+      { id: 'E', x: 2, y: 0 },
+    ];
+
+    const expected = ['NW', 'N', 'NE', 'E', 'SE', 'S', 'SW', 'W'];
+
+    let [refX, refY] = [-1, -1]; // same as NW
+    let sorted = getPoints().sort(
+      getSortPointsClockwiseFunction({ x: 0, y: 0 }, { x: refX, y: refY }),
+    );
+    assert.deepEqual(sorted.map((point) => point.id), expected);
+
+    [refX, refY] = [-1.2, -0.8];
+    sorted = getPoints().sort(getSortPointsClockwiseFunction({ x: 0, y: 0 }, { x: refX, y: refY }));
+    assert.deepEqual(sorted.map((point) => point.id), expected);
+  });
+
+  it('sorts points clockwise with numeric reference', () => {
+    const points = [
+      { id: 'NE', x: 1, y: -1 },
+      { id: 'NW', x: -1, y: -1 },
+      { id: 'N', x: 0, y: -1 },
+    ];
+
+    const sorted = points.sort(
+      getSortPointsClockwiseFunction({ x: 0, y: 0 }, 0), // reference is south
+    );
+
+    assert.deepEqual(sorted.map((point) => point.id), ['NW', 'N', 'NE']);
+  });
+
+  it('keeps points in input order when all angles are equal', () => {
+    const points = [
+      { id: '1', x: 0, y: -3 },
+      { id: '2', x: 0, y: -4 },
+      { id: '3', x: 0, y: -1 },
+      { id: '4', x: 0, y: -2 },
+    ];
+
+    const sorted = points.sort(getSortPointsClockwiseFunction({ x: 0, y: 0 }));
+    assert.deepEqual(sorted.map((point) => point.id), ['1', '2', '3', '4']);
+  });
 });

ui/config/config.ts

@@ -149,6 +149,7 @@ export const kPrefixToCategory = {
     de: 'Benutzerdefinierte Entwickler Trigger',
     cn: '自定义开发者触发器',
     ko: '커스텀 개발자 트리거',
+    tc: '自定義開發者觸發器',
   },
   'user': {
     en: 'User Triggers',

ui/raidboss/data/02-arr/dungeon/aurum_vale.ts

@@ -13,6 +13,7 @@ const triggerSet: TriggerSet<Data> = {
     de: 'Vor der 7.4 Überarbeitung',
     cn: '7.4改版前',
     ko: '7.4 개편 전',
+    tc: '7.4改版前',
   },
   triggers: [
     {

ui/raidboss/data/04-sb/dungeon/shisui_of_the_violet_tides.ts

@@ -14,6 +14,7 @@ const triggerSet: TriggerSet<Data> = {
     de: 'Vor der 7.5 Überarbeitung',
     cn: '7.5改版前',
     ko: '7.5 개편 전',
+    tc: '7.5改版前',
   },
   timelineFile: 'shisui_of_the_violet_tides.txt',
   triggers: [

ui/raidboss/data/04-sb/trial/shinryu-ex.ts

@@ -98,6 +98,7 @@ const triggerSet: TriggerSet<Data> = {
           de: 'Eis: Sammeln + nicht bewegen',
           cn: '冰: 集合 + 不要动',
           ko: '얼음: 모이기 + 이동 멈추기',
+          tc: '冰: 集合 + 不要動',
         },
       },
     },
@@ -760,7 +761,6 @@ const triggerSet: TriggerSet<Data> = {
     },
     {
       'locale': 'tc',
-      'missingTranslations': true,
       'replaceSync': {
         'Cocoon': '光繭',
         'Icicle': '冰柱',

ui/raidboss/data/04-sb/ultimate/ultima_weapon_ultimate.ts

@@ -770,7 +770,7 @@ const triggerSet: TriggerSet<Data> = {
           // The two close nails are 45 degrees apart.
           if (next8Dir - this8Dir === 1 || this8Dir - next8Dir === 7) {
             const between16Dir = this8Dir * 2 + 1;
-            const outputKey = Directions.output16Dir[between16Dir] ?? 'unknown';
+            const outputKey = Directions.outputFrom16DirNum(between16Dir);
             return output.text!({ dir: output[outputKey]!() });
           }
         }

ui/raidboss/data/04-sb/ultimate/unending_coil_ultimate.ts

@@ -1810,7 +1810,7 @@ const triggerSet: TriggerSet<Data> = {
         const towerDir = towersMap[(wantedIdx + naelIdx) % 8];
 
         const myTowerDir = towerDir !== undefined
-          ? Directions.output16Dir[towerDir] ?? 'unknown'
+          ? Directions.outputFrom16DirNum(towerDir)
           : 'unknown';
 
         return output.tower!({