@cc-component/cc-fly 0.0.0-stage → 1.0.0

package/assets/fly/base/FlyModule.ts

@@ -0,0 +1,145 @@
+import { randomRangeInt, tween, misc } from 'cc';
+import { Vec3 } from 'cc';
+import { _decorator, Component, Node, v3 } from 'cc';
+import { FlyBasePlayer } from './FlyBasePlayer';
+import { FlySkiiManager } from './FlySkiiManager';
+import { PlayerBuffType } from './FlyPlayerBuffSystem';
+
+const { ccclass, property } = _decorator;
+
+@ccclass('FlyModule')
+export class FlyModule {
+    private static instance: FlyModule;
+    private constructor() {
+
+    }
+    static get Ins() {
+        if (!this.instance) {
+            this.instance = new FlyModule();
+        }
+        return this.instance;
+    }
+    /**
+     * 开始抛物线缓动
+     * @param item 运动节点
+     * @param target_postion 目标位置
+     * @param update 更新 运动中回调
+     * @param offset_ratio 最高点 的偏移量
+     * @param time 动画时间
+     * @param speed 速度，>0 时优先使用速度计算时间
+     * @param is_random 是否随机上下方向
+     * @param start_position 起始位置--比如 父节点的位置和 抛物线的起点位置 不同，，用父节点的起始位置就传入
+     */
+    static RunParabola(item: Node, target_postion: Vec3, update: (ratio: number) => void, param?: { offset_ratio?: number, is_random: boolean, time?: number, speed?: number, scale_offset_with_distance?: boolean, offset_reference_distance?: number, start_position?: Vec3, is_end_clone?: boolean }) {
+        FlyModule.Ins.RunParabolaTween(item, target_postion, update, param)
+    }
+
+    RunParabolaTween(item: Node, target_postion: Vec3, update: (ratio: number) => void, param?: { offset_ratio?: number, is_random: boolean, time?: number, speed?: number, scale_offset_with_distance?: boolean, offset_reference_distance?: number, start_position?: Vec3, is_end_clone?: boolean }) {
+        const distance = Vec3.distance(target_postion, item.worldPosition)
+        const duration = param?.speed && param.speed > 0 ? (distance / param.speed) : (param?.time ?? 1)
+
+        const start = item.worldPosition.clone();
+        const end = target_postion
+
+
+        let fx = end.x >= (param?.start_position ? param?.start_position.x : start.x) ? 1 : -1;//朝向始终 是上抛物线，
+        if (param?.is_random) { fx = [-1, 1][randomRangeInt(0, 2)] }
+
+        const direction = end.clone().subtract(start).normalize();
+        let offset = direction.clone().multiplyScalar(distance * 0.5);
+        offset = start.add(offset)
+        //垂直方向的位置
+        const perpendicular = new Vec3(-direction.y, direction.x, 0);
+        const offsetRatio = param?.offset_ratio ?? 0.5;
+        const referenceDistance = Math.max(param?.offset_reference_distance ?? 500, 0.001);
+        const offsetScaleDistance = param?.scale_offset_with_distance === false ? referenceDistance : distance;
+        const offsetMagnitude = offsetScaleDistance * offsetRatio;
+        offset = offset.add(perpendicular.multiplyScalar(offsetMagnitude * fx))
+        offset = v3(offset.x, offset.y);
+
+        this.RunTween(item, offset, target_postion, duration, update)
+    }
+
+    RunTween(target: Node, peakPoint, endPoint, duration, update) {
+        let points = [target.worldPosition.clone(), peakPoint, endPoint];
+        const data = { ratio: 0 }
+        tween(data).to(duration, { ratio: 1 },    // 这里以node的位置信息坐标缓动的目标 
+            {
+                // ITweenOption 的接口实现：
+                onUpdate: (target_data: { ratio: 0 }, ratio: number) => {
+                    const pos = this.GetPosition(target_data.ratio, points)
+                    const pos1 = this.GetPosition(Math.max(ratio * 1.1, 0.001), points)
+                    target.setWorldPosition(pos.x, pos.y, pos.z);
+                    this.LookAt(target, pos1)
+                    update && update(ratio, pos)
+                }
+            }).start();
+    }
+
+    GetPosition(ratio, points) {
+        const t = ratio
+        // 二次贝塞尔曲线公式
+        let x = (1 - t) * (1 - t) * points[0].x + 2 * (1 - t) * t * points[1].x + t * t * points[2].x;
+        let y = (1 - t) * (1 - t) * points[0].y + 2 * (1 - t) * t * points[1].y + t * t * points[2].y;
+        const pos = v3(x, y);
+        return pos
+    }
+
+    LookAt(target: Node, endPoint: Vec3) {
+        const direction = endPoint.clone().subtract(target.worldPosition).normalize(); // 计算A点指向B点的方向向量
+        const angle = Math.atan2(direction.x, direction.y); // 计算夹角（弧度）
+        let euler = v3(0, 0, -misc.radiansToDegrees(angle)); // 应用欧拉角到A点
+        target.eulerAngles = euler
+        return angle;
+    }
+
+    getEuler(start: Vec3, end: Vec3) {
+        const direction = end.clone().subtract(start).normalize(); // 计算A点指向B点的方向向量
+        const angle = Math.atan2(direction.x, direction.y); // 计算夹角（弧度）
+        let euler = v3(0, 0, -misc.radiansToDegrees(angle)); // 应用欧拉角到A点
+        return -misc.radiansToDegrees(angle);
+    }
+
+    /**
+     * 生成抛物线上的指定数量坐标点
+     * @param start 起始点
+     * @param peak 控制点（峰值点）
+     * @param end 结束点
+     * @param count 点的数量
+     * @returns 坐标点数组
+     */
+    generateParabolaPoints(param: { start: Vec3, end: Vec3, offset_ratio: number, count: number }) {
+        //中心点
+        const distance = Vec3.distance(param.start, param.end)
+        const direction = param.end.clone().subtract(param.start).normalize();
+        let center = direction.clone().multiplyScalar(distance * 0.5);
+        center = param.start.clone().add(center)
+        //中心点垂直方向的位置
+        const perpendicular = new Vec3(-direction.y, direction.x, 0);
+        center = center.add(perpendicular.multiplyScalar(distance * (param?.offset_ratio ?? 0.5)))
+        const points = [param.start, center, param.end];
+        const result: { positions: Vec3, rotion: number }[] = []
+        for (let i = 0; i < param.count; i++) {
+            const ratio = i / (param.count - 1);
+            const pos = this.GetPosition(ratio, points);
+            const pos1 = this.GetPosition(Math.max(ratio * 1.1, 0.001), points)
+            const euler = this.getEuler(pos, pos1)
+            result.push({ positions: pos, rotion: euler });
+        }
+        return result;
+    }
+
+
+    //#endregion
+    /**技能释放动画 */
+    // static OnSkillAnim<T extends FlyBasePlayer>(primaryTarget: T, candidateTargets: readonly T[], onHit: (target: T) => void): void {
+
+
+
+    // }
+    static OnSkillAnim<T extends FlyBasePlayer>(call: (buffType: PlayerBuffType | any, attacker: T, primaryTarget: T, candidateTargets: readonly T[], onHit: (target: T) => void) => void): void {
+        FlySkiiManager.getInstance().EmitSkillAnim = call;
+    }
+}
+
+window.FlyModule = FlyModule;

package/assets/fly/base/FlyModule.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "62642350-f8d4-4516-8def-6fb058e4f52c",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/fly/base/FlyNodePoolUtil.ts

@@ -0,0 +1,56 @@
+import { instantiate, Node, NodePool, Prefab } from 'cc';
+
+export class FlyNodePoolUtil {
+    private static readonly pools = new Map<string, NodePool>();
+    private static readonly templates = new Map<string, { template: Node | Prefab; parent: Node | null }>();
+    private static readonly nodePoolKeys = new WeakMap<Node, string>();
+    private static readonly maxPoolSize = 20;
+
+    static register(key: string, template: Node | Prefab, parent: Node | null = template instanceof Node ? template.parent : null): void {
+        const registration = this.templates.get(key);
+        if (registration && registration.template !== template) {
+            throw new Error(`NodePool key "${key}" is already used by another template.`);
+        }
+        this.templates.set(key, { template, parent });
+    }
+
+    static get(key: string): Node {
+        const registration = this.templates.get(key);
+        if (!registration) {
+            throw new Error(`报错了：NodePool key "${key}" has not been registered.`);
+        }
+
+        let pool = this.pools.get(key);
+        if (!pool) {
+            pool = new NodePool();
+            this.pools.set(key, pool);
+        }
+
+        const node = pool.get() ?? (registration.template instanceof Node
+            ? instantiate(registration.template)
+            : instantiate(registration.template));
+        this.nodePoolKeys.set(node, key);
+        node.setParent(registration.parent);
+        node.active = true;
+        return node;
+    }
+
+    static put(node: Node): void {
+        if (!node?.isValid) return;
+
+        const key = this.nodePoolKeys.get(node);
+        const pool = key ? this.pools.get(key) : undefined;
+        if (!pool || pool.size() >= this.maxPoolSize) {
+            this.nodePoolKeys.delete(node);
+            node.destroy();
+            return;
+        }
+        pool.put(node);
+    }
+
+    static clear(key: string): void {
+        this.pools.get(key)?.clear();
+        this.pools.delete(key);
+        this.templates.delete(key);
+    }
+}

package/assets/fly/base/FlyNodePoolUtil.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f3c149df-71ab-4d52-9c37-b64f4250d190",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}