@chiyou/minigame-framework 1.0.0 → 1.0.2

package/assets/Scripts/Framework/Manager/UserMgr.ts

@@ -0,0 +1,162 @@
+import { FrameworkBase } from "../Definition/FrameworkBase";
+import { LoginResult, LoginResultType } from "../Definition/UserDefinition";
+import { LogUtils } from "../Utils/LogUtils";
+import { BaseMgr } from "./BaseMgr";
+
+export class UserMgr extends BaseMgr {
+    
+    public static Instance: UserMgr = null;
+    static TAG: string = "UserMgr";
+
+    private newUser: boolean = false;
+
+    private isLogin: boolean = false;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (UserMgr.Instance === null) {
+            UserMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this.initNewUser();
+        
+        LogUtils.Instance.log(UserMgr.TAG, "init() finished.");
+    }
+
+    private initNewUser(): void {
+        let userMgr_NewUser = localStorage.getItem(FrameworkBase.LocalStorage.Key_UserMgr_NewUser);
+        let userInfo_NewUser = localStorage.getItem(FrameworkBase.LocalStorage.Key_UserInfo_NewUser);
+        
+        if (userMgr_NewUser !== null && userMgr_NewUser === "0") {
+            this.newUser = false;
+        } else if (userInfo_NewUser !== null && userInfo_NewUser === "0") {
+            this.newUser = false;
+            localStorage.removeItem(FrameworkBase.LocalStorage.Key_UserInfo_NewUser);
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_UserMgr_NewUser, "0");
+        } else {
+            this.newUser = true;
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_UserMgr_NewUser, "0");
+        }
+
+        LogUtils.Instance.log(UserMgr.TAG, "isNewUser=" + this.isNewUser());
+    }
+
+    public isNewUser(): boolean {
+        return this.newUser;
+    }
+
+    public login(needForceLogin: boolean, callback: Function): void {
+        if (callback === null) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            this.isLogin = false;
+            callback({
+                type: LoginResultType.Type_LoginFail_ContinueGame,
+                code: "",
+                accountId: 0,
+            });
+            return;
+        }
+
+        if (!needForceLogin) {
+            this._checkSession().then((loginResult: LoginResult) => {
+                this.isLogin = true;
+                callback(loginResult);
+            }).catch(() => {
+                this._login().then((loginResult: LoginResult) => {
+                    this.isLogin = true;
+                    callback(loginResult);
+                }).catch((loginResult: LoginResult) => {
+                    this.isLogin = false;
+                    callback(loginResult);
+                });
+            });
+        } else {
+            this._login().then((loginResult: LoginResult) => {
+                    this.isLogin = true;
+                    callback(loginResult);
+                }).catch((loginResult: LoginResult) => {
+                    this.isLogin = false;
+                    callback(loginResult);
+                });
+        }
+    }
+
+    private _checkSession(): Promise<LoginResult> {
+        return new Promise((resolve, reject) => {
+            if (this.getPlatformAdapter() === null) {
+                reject();
+                return;
+            }
+
+            this.getPlatformAdapter().checkSession(
+                () => {
+                    resolve({
+                        type: LoginResultType.Type_SessionAvailable,
+                        code: "",
+                        accountId: 0,
+                    });
+                }, () => {
+                    reject();
+                });
+        });
+    }
+
+    private _login(): Promise<LoginResult> {
+        return new Promise((resolve, reject) => {
+            if (this.getPlatformAdapter() === null) {
+                reject("");
+                return;
+            }
+
+            this.getPlatformAdapter().login(
+                (code: string, accountId: number) => {
+                    if (code.length > 0) {
+                        resolve({
+                            type: LoginResultType.Type_LoginSuccess_Auth_Code,
+                            code: code,
+                            accountId: 0,
+                        });
+                    } else if (accountId > 0) {
+                        resolve({
+                            type: LoginResultType.Type_LoginSuccess_Auth_AccountID,
+                            code: "",
+                            accountId: accountId,
+                        });
+                    }
+
+                    reject({
+                        type: LoginResultType.Type_LoginFail_ContinueGame,
+                        code: "",
+                        accountId: 0,
+                    });
+                }, (canContinueGame: boolean) => {
+                    if (canContinueGame) {
+                        reject({
+                            type: LoginResultType.Type_LoginFail_ContinueGame,
+                            code: "",
+                            accountId: 0,
+                        });
+                    } else {
+                        reject({
+                            type: LoginResultType.Type_LoginFail_ExitGame,
+                            code: "",
+                            accountId: 0,
+                        });
+                    }
+                });
+        });
+    }
+
+    public isLogined(): boolean {
+        return this.isLogin;
+    }
+}

package/assets/Scripts/Framework/Manager/UserMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f565e7db-8282-449c-913b-4a8670c48b30",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Manager.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "b57f890c-e00e-49b0-bf23-aeb820b9da76",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Utils/BezierUtils.ts

@@ -0,0 +1,273 @@
+import { _decorator, Component, Node, tween, Tween, TweenEasing, v2, Vec2, Vec3 } from 'cc';
+const { ccclass } = _decorator;
+
+export interface BezierMoveOptions {
+    rotateToDirection?: boolean;         // 是否根据运动方向调整朝向
+    rotateSpeed?: number;               // 旋转速度系数
+    rotateOffset?: number;              // 旋转偏移角度（度数）
+    lookAtTarget?: Node | Vec3;         // 看向某个目标
+    smoothing?: number;                 // 角度平滑系数（0-1）
+    onUpdate?: (ratio: number, position: Vec3, rotation: number) => void; // 自定义更新回调
+}
+
+@ccclass
+export class BezierUtils extends Component {
+
+    /**
+     * 二阶贝塞尔曲线移动（带朝向控制）
+     * @param target 目标节点
+     * @param controlPoint 控制点
+     * @param endPoint 终点
+     * @param duration 持续时间
+     * @param easing 缓动函数
+     * @param options 配置选项
+     */
+    static quadraticTween(
+        target: Node,
+        controlPoint: Vec3,
+        endPoint: Vec3,
+        duration: number,
+        easing: TweenEasing = 'linear',
+        options: BezierMoveOptions = {},
+    ): Tween<Node> {
+        const startPoint = target.position.clone();
+        const startRotation = target.angle;
+        let lastPosition = startPoint.clone();
+        let lastRotation = 0;
+        
+        const rotateToDirection = options.rotateToDirection ?? false;
+        const rotateSpeed = options.rotateSpeed ?? 1;
+        const rotateOffset = options.rotateOffset ?? 0;
+        const smoothing = options.smoothing ?? 0.3;
+        
+        return tween(target)
+            .to(duration, {}, {
+                onStart: (target: Node) => {
+                    target.setPosition(startPoint);
+                    // 如果需要调整朝向
+                    if (rotateToDirection || options.lookAtTarget) {
+                        let targetAngle = 0;
+                        
+                        if (options.lookAtTarget) {
+                            // 看向目标
+                            targetAngle = this.calculateLookAtAngle(
+                                target.position,
+                                options.lookAtTarget instanceof Node 
+                                    ? options.lookAtTarget.position 
+                                    : options.lookAtTarget
+                            );
+                        } else {
+                            // 根据移动方向调整朝向
+                            targetAngle = this.calculateMovementAngle(
+                                lastPosition,
+                                target.position,
+                                target.angle,
+                                rotateSpeed
+                            );
+                        }
+                        
+                        // 应用角度偏移
+                        targetAngle += rotateOffset;
+                        
+                        // 角度平滑
+                        if (smoothing > 0 && smoothing < 1) {
+                            const currentAngle = target.angle;
+                            const smoothedAngle = currentAngle + (targetAngle - currentAngle) * smoothing;
+                            target.angle = smoothedAngle;
+                            lastRotation = smoothedAngle;
+                        } else {
+                            target.angle = targetAngle;
+                            lastRotation = targetAngle;
+                        }
+                    }
+                    lastPosition = startPoint.clone();
+                    lastRotation = startRotation;
+
+                    // 保存当前位置用于计算下一帧方向
+                    lastPosition.set(target.position);
+                },
+                onUpdate: (target: Node, ratio: number) => {
+                    const t = ratio;
+                    const u = 1 - t;
+                    
+                    // 计算当前位置
+                    const x = u * u * startPoint.x + 
+                              2 * u * t * controlPoint.x + 
+                              t * t * endPoint.x;
+                    
+                    const y = u * u * startPoint.y + 
+                              2 * u * t * controlPoint.y + 
+                              t * t * endPoint.y;
+                    
+                    const z = u * u * startPoint.z + 
+                              2 * u * t * controlPoint.z + 
+                              t * t * endPoint.z;
+                    
+                    target.setPosition(x, y, z);
+                    
+                    // 如果需要调整朝向
+                    if (rotateToDirection || options.lookAtTarget) {
+                        let targetAngle = 0;
+                        
+                        if (options.lookAtTarget) {
+                            // 看向目标
+                            targetAngle = this.calculateLookAtAngle(
+                                target.position,
+                                options.lookAtTarget instanceof Node 
+                                    ? options.lookAtTarget.position 
+                                    : options.lookAtTarget
+                            );
+                        } else {
+                            // 根据移动方向调整朝向
+                            targetAngle = this.calculateMovementAngle(
+                                lastPosition,
+                                target.position,
+                                target.angle,
+                                rotateSpeed
+                            );
+                        }
+                        
+                        // 应用角度偏移
+                        targetAngle += rotateOffset;
+                        
+                        // 角度平滑
+                        if (smoothing > 0 && smoothing < 1) {
+                            const currentAngle = target.angle;
+                            const smoothedAngle = currentAngle + (targetAngle - currentAngle) * smoothing;
+                            target.angle = smoothedAngle;
+                            lastRotation = smoothedAngle;
+                        } else {
+                            target.angle = targetAngle;
+                            lastRotation = targetAngle;
+                        }
+                    }
+                    
+                    // 保存当前位置用于计算下一帧方向
+                    lastPosition.set(target.position);
+                    
+                    // 调用自定义回调
+                    options.onUpdate?.(ratio, target.position.clone(), target.angle);
+                },
+                onComplete: (target: Node) => {
+                    // 如果需要调整朝向
+                    if (rotateToDirection || options.lookAtTarget) {
+                        let targetAngle = 0;
+                        
+                        if (options.lookAtTarget) {
+                            // 看向目标
+                            targetAngle = this.calculateLookAtAngle(
+                                target.position,
+                                options.lookAtTarget instanceof Node 
+                                    ? options.lookAtTarget.position 
+                                    : options.lookAtTarget
+                            );
+                        } else {
+                            // 根据移动方向调整朝向
+                            targetAngle = this.calculateMovementAngle(
+                                lastPosition,
+                                target.position,
+                                target.angle,
+                                rotateSpeed
+                            );
+                        }
+                        
+                        // 应用角度偏移
+                        targetAngle += rotateOffset;
+                        
+                        // 角度平滑
+                        if (smoothing > 0 && smoothing < 1) {
+                            const currentAngle = target.angle;
+                            const smoothedAngle = currentAngle + (targetAngle - currentAngle) * smoothing;
+                            target.angle = smoothedAngle;
+                            lastRotation = smoothedAngle;
+                        } else {
+                            target.angle = targetAngle;
+                            lastRotation = targetAngle;
+                        }
+                    }
+                    lastPosition = startPoint.clone();
+                    lastRotation = startRotation;
+
+                    // 保存当前位置用于计算下一帧方向
+                    lastPosition.set(target.position);
+                },
+                easing: easing,
+            })
+            .start();
+    }
+
+    /**
+     * 计算看向目标的角度
+     */
+    private static calculateLookAtAngle(from: Vec3, to: Vec3): number {
+        const direction = new Vec3();
+        Vec3.subtract(direction, to, from);
+        return this.vectorToAngle(direction);
+    }
+
+    /**
+     * 根据移动方向计算角度
+     */
+    private static calculateMovementAngle(
+        lastPos: Vec3,
+        currentPos: Vec3,
+        currentAngle: number,
+        speed: number = 1
+    ): number {
+        const delta = new Vec3();
+        Vec3.subtract(delta, currentPos, lastPos);
+        
+        // 如果移动距离很小，保持当前角度
+        if (delta.lengthSqr() < 0.0001) {
+            return currentAngle;
+        }
+        
+        return this.vectorToAngle(delta);
+    }
+
+    /**
+     * 向量转角度（2D平面，相对于X轴正方向，逆时针为正）
+     */
+    private static vectorToAngle(vector: Vec3): number {
+        // 计算相对于X轴正方向的角度（弧度）
+        const rad = Math.atan2(vector.y, vector.x);
+        // 转换为度（Cocos Creator 使用度作为单位）
+        return rad * 180 / Math.PI;
+    }
+
+    /**
+     * 生成控制点
+     */
+    static getControlPoint2D(start: Vec2, end: Vec2, options?: {
+        heightScale?: number,      // 曲线高度比例
+        maxHeight?: number,     // 最大高度
+        direction?: number,   // 1:向上, -1:向下
+        intensity?: number    // 强度 0-1
+    }): Vec2 {
+        const { heightScale = 1, maxHeight= 200, direction = 1, intensity = 0.5 } = options || {};
+        const height = Math.min(Vec2.distance(start, end) * heightScale, maxHeight);
+
+        const mid = start.add(end).multiplyScalar(0.5);
+        const dir = end.subtract(start);
+        const perpendicular = v2(-dir.y, dir.x).normalize();
+        
+        return mid.add(perpendicular.multiplyScalar(height * direction * intensity));
+    }
+
+    /**
+     * 通过角度生成控制点
+     */
+    public static getControlPointByAngle2D(start: Vec2, end: Vec2, options?: {
+        angle?: number,
+        distance?: number, 
+    }): Vec2 {
+        const {angle = Math.PI / 2, distance = 200} = options || {};
+        const midPoint = start.add(end).multiplyScalar(0.5);
+
+        // 计算控制点位置
+        const x = midPoint.x + Math.cos(angle) * distance;
+        const y = midPoint.y + Math.sin(angle) * distance;
+        
+        return v2(x, y);
+    }
+}

package/assets/Scripts/Framework/Utils/BezierUtils.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "5fb9e86a-42f3-44e1-82ed-9dc98ff04689",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}