init: 2.B

packages-user/data-utils/package.json

@@ -0,0 +1,6 @@
+{
+    "name": "@user/data-utils",
+    "dependencies": {
+        "@user/data-base": "workspace:*"
+    }
+}

packages-user/data-utils/src/index.ts

@@ -0,0 +1,2 @@
+export * from './range';
+export * from './utils';

packages-user/data-utils/src/range.ts

@@ -0,0 +1,86 @@
+import { isNil } from 'lodash-es';
+
+interface RangeTypeData {
+    square: { x: number; y: number; d: number };
+    rect: { x: number; y: number; w: number; h: number };
+    manhattan: { x: number; y: number; d: number };
+}
+
+type InRangeFn<E extends Partial<Loc>, T> = (item: E, data: T) => boolean;
+
+export class Range {
+    static rangeType: Record<string, RangeType> = {};
+
+    /**
+     * 获取一个范围类型，并进行判断
+     * @param type 范围类型
+     */
+    type<T extends string>(
+        type: T
+    ): T extends keyof RangeTypeData ? RangeType<RangeTypeData[T]> : RangeType {
+        return Range.rangeType[type] as T extends keyof RangeTypeData
+            ? RangeType<RangeTypeData[T]>
+            : RangeType;
+    }
+
+    /**
+     * 注册一个新的范围类型
+     * @param type 范围类型
+     * @param fn 判断是否在范围内的函数
+     */
+    static register<K extends keyof RangeTypeData>(
+        type: K,
+        fn: InRangeFn<Partial<Loc>, RangeTypeData[K]>
+    ): void;
+    static register(type: string, fn: InRangeFn<Partial<Loc>, any>): void;
+    static register(type: string, fn: InRangeFn<Partial<Loc>, any>): void {
+        const range = new RangeType(type, fn);
+        this.rangeType[type] = range;
+    }
+}
+
+class RangeType<Type = any> {
+    readonly type: string;
+    /**
+     * 判断一个元素是否在指定范围内
+     * @param item 要判断的元素
+     * @param data 范围数据
+     */
+    readonly inRange: InRangeFn<Partial<Loc>, Type>;
+
+    constructor(type: string, fn: InRangeFn<Partial<Loc>, Type>) {
+        this.type = type;
+        this.inRange = fn;
+    }
+
+    /**
+     * 扫描一个列表中所有在范围内的元素
+     * @param items 元素列表
+     * @param data 范围数据
+     */
+    scan<T extends Partial<Loc>>(items: Iterable<T>, data: Type): T[] {
+        const res: T[] = [];
+        for (const ele of items) {
+            if (this.inRange(ele, data)) {
+                res.push(ele);
+            }
+        }
+        return res;
+    }
+}
+
+Range.register('square', (item, { x, y, d }) => {
+    if (isNil(item.x) || isNil(item.y)) return false;
+    const r = Math.floor(d / 2);
+    return Math.abs(item.x - x) <= r && Math.abs(item.y - y) <= r;
+});
+Range.register('rect', (item, { x, y, w, h }) => {
+    if (isNil(item.x) || isNil(item.y)) return false;
+    const ex = x + w;
+    const ey = y + h;
+    return item.x >= x && item.y >= y && item.x < ex && item.y < ey;
+});
+Range.register('manhattan', (item, { x, y, d }) => {
+    if (isNil(item.x) || isNil(item.y)) return false;
+    return Math.abs(item.x - x) + Math.abs(item.y - y) < d;
+});

packages-user/data-utils/src/utils.ts

@@ -0,0 +1,179 @@
+/**
+ * 滑动数组
+ * @param arr
+ * @param delta
+ */
+export function slide<T>(arr: T[], delta: number): T[] {
+    if (delta === 0) return arr;
+    delta %= arr.length;
+    if (delta > 0) {
+        arr.unshift(...arr.splice(arr.length - delta, delta));
+        return arr;
+    }
+    if (delta < 0) {
+        arr.push(...arr.splice(0, -delta));
+        return arr;
+    }
+    return arr;
+}
+
+const backDirMap: Record<Dir2, Dir2> = {
+    up: 'down',
+    down: 'up',
+    left: 'right',
+    right: 'left',
+    leftup: 'rightdown',
+    rightup: 'leftdown',
+    leftdown: 'rightup',
+    rightdown: 'leftup'
+};
+
+export function backDir(dir: Dir): Dir;
+export function backDir(dir: Dir2): Dir2;
+export function backDir(dir: Dir2): Dir2 {
+    return backDirMap[dir];
+}
+
+export function has<T>(v: T): v is NonNullable<T> {
+    return v !== null && v !== void 0;
+}
+
+export function maxGameScale(n: number = 0) {
+    const index = core.domStyle.availableScale.indexOf(core.domStyle.scale);
+    core.control.setDisplayScale(
+        core.domStyle.availableScale.length - 1 - index - n
+    );
+    if (!core.isPlaying() && core.flags.enableHDCanvas) {
+        // @ts-ignore
+        core.domStyle.ratio = Math.max(
+            window.devicePixelRatio || 1,
+            core.domStyle.scale
+        );
+        core.resize();
+    }
+}
+
+export function ensureArray<T>(arr: T): T extends any[] ? T : T[] {
+    // @ts-ignore
+    return arr instanceof Array ? arr : [arr];
+}
+
+export function ofDir(x: number, y: number, dir: Dir2): LocArr {
+    const { x: dx, y: dy } = core.utils.scan2[dir];
+    return [x + dx, y + dy];
+}
+
+/**
+ * 计算曼哈顿距离
+ */
+export function manhattan(x1: number, y1: number, x2: number, y2: number) {
+    return Math.abs(x1 - x2) + Math.abs(y1 - y2);
+}
+
+/**
+ * 检查一个点是否在当前超大地图 v2 优化范围内
+ */
+export function checkV2(x?: number, y?: number) {
+    return (
+        has(x) &&
+        has(y) &&
+        !(
+            core.bigmap.v2 &&
+            (x < core.bigmap.posX - core.bigmap.extend ||
+                x > core.bigmap.posX + core._WIDTH_ + core.bigmap.extend ||
+                y < core.bigmap.posY - core.bigmap.extend ||
+                y > core.bigmap.posY + core._HEIGHT_ + core.bigmap.extend)
+        )
+    );
+}
+
+export function formatDamage(damage: number): DamageString {
+    let dam = '';
+    let color = '';
+    if (!Number.isFinite(damage)) {
+        dam = '???';
+        color = '#f22';
+    } else {
+        dam = core.formatBigNumber(damage, true);
+        if (damage <= 0) color = '#1f1';
+        else if (damage < core.status.hero.hp / 3) color = '#fff';
+        else if (damage < (core.status.hero.hp * 2) / 3) color = '#ff0';
+        else if (damage < core.status.hero.hp) color = '#f93';
+        else color = '#f22';
+    }
+
+    return { damage: dam, color: color as Color };
+}
+
+/**
+ * 判断一个数组的数值是否全部相等
+ * @param arr 要判断的数组
+ */
+export function equal(arr: number[]): boolean;
+/**
+ * 判断一个数组的元素的某个属性的数值是否全部相等
+ * @param arr 要判断的数组
+ * @param key 要判断的属性名
+ */
+export function equal<T>(arr: T[], key: keyof T): boolean;
+export function equal(arr: any, key?: any) {
+    if (has(key)) {
+        for (let i = 1; i < arr.length; i++) {
+            if (arr[i][key] !== arr[0][key]) return false;
+        }
+        return true;
+    } else {
+        for (let i = 1; i < arr.length; i++) {
+            if (arr[i] !== arr[0]) return false;
+        }
+        return true;
+    }
+}
+
+/**
+ * 获得一个数组的数值的最大值和最小值
+ * @param arr 要获得的数组
+ */
+export function boundary(arr: number[]): [number, number];
+/**
+ * 获得一个数组的元素的某个属性的数值的最大值和最小值
+ * @param arr 要获得的数组
+ * @param key 要获得的属性名
+ */
+export function boundary<T>(arr: T[], key: keyof T): [number, number];
+export function boundary(arr: any, key?: any) {
+    if (has(key)) {
+        let min = arr[0][key];
+        let max = arr[0][key];
+        for (let i = 1; i < arr.length; i++) {
+            const ele = arr[i][key];
+            if (ele < min) min = ele;
+            if (ele > max) max = ele;
+        }
+        return [min, max];
+    } else {
+        let min = arr[0];
+        let max = arr[0];
+        for (let i = 1; i < arr.length; i++) {
+            const ele = arr[i];
+            if (ele < min) min = ele;
+            if (ele > max) max = ele;
+        }
+        return [min, max];
+    }
+}
+
+/**
+ * 获取两个坐标的相对方向
+ * @param from 初始坐标
+ * @param to 指向坐标
+ */
+export function findDir(from: Loc, to: Loc): Dir | 'none' {
+    const dx = Math.sign(to.x - from.x);
+    const dy = Math.sign(to.y - from.y);
+    return (
+        (Object.entries(core.utils.scan).find(v => {
+            return v[1].x === dx && v[1].y === dy;
+        })?.[0] as Dir) ?? 'none'
+    );
+}