drgame-cc 1.0.49 → 1.0.52

package/drscript/focus/FocusManager.ts

@@ -1,4 +1,6 @@
 import { KeyCode } from "../ad-sdk/ad-sdk";
+import { FingerStyle } from "../Define";
+import FocusVisualLayer from "./FocusVisualLayer";
 
 export interface FocusRuntimeItem {
     node: cc.Node;
@@ -25,8 +27,8 @@ interface ScopeInfo {
 
 export default class FocusManager {
     private static readonly FOCUS_SCALE_ACTION_TAG: number = 9911;
-    private static readonly BASE_SCALE_X_KEY: string = "__tvFocusBaseScaleX";
-    private static readonly BASE_SCALE_Y_KEY: string = "__tvFocusBaseScaleY";
+    private static readonly PERP_WEIGHT = 3;  // 垂直方向惩罚权重
+    private static readonly BASE_SCALE_KEY: string = "__tvFocusBaseScale";
     private static items: FocusRuntimeItem[] = [];
     private static itemMap: { [uuid: string]: FocusRuntimeItem } = {};
     private static scopeMap: { [uuid: string]: string } = {};
@@ -35,43 +37,44 @@ export default class FocusManager {
     private static activeScopeId: string = "";
     private static listeners: FocusListener[] = [];
 
+    // ---- 视觉层管理 ----
+    private static visualLayer: FocusVisualLayer | null = null;
+    private static _focusStyle: FingerStyle = FingerStyle.Default;
+    private static _focusZIndex: number = 800;
+    private static _cursorVisible: boolean = true;
+
     private static readonly DEFAULT_FOCUS_SCALE = 1.08;
 
-    public static register(target: cc.Node | any, options: { scopeId?: string; onFocus?: Function; onBlur?: Function; onClick?: Function; focusScale?: number; showCursor?: boolean; offset?: cc.Vec2 } = {}): void {
-        let node = this.resolveNode(target);
+    public static register(node: cc.Node, options: { scopeId?: string; onFocus?: Function; onBlur?: Function; onClick?: Function; focusScale?: number; showCursor?: boolean; offset?: cc.Vec2 } = {}): void {
         if (!node) return;
-        let component = this.resolveComponent(target, node);
         this.unregister(node);
 
-        let uuid = node.uuid;
-        this.getNodeBaseScale(node);
-
-        let scopeId = options.scopeId || (component && component.scopeId) || this.activeScopeId;
-        this.scopeMap[uuid] = scopeId;
+        let scopeId = options.scopeId || this.activeScopeId;
+        this.scopeMap[node.uuid] = scopeId;
 
         let item: FocusRuntimeItem = {
             node: node,
-            onFocus: options.onFocus || (component && component.onFocus),
-            onBlur: options.onBlur || (component && component.onBlur),
+            onFocus: options.onFocus,
+            onBlur: options.onBlur,
             onClick: options.onClick,
-            focusScale: options.focusScale || (component && component.focusScale) || this.DEFAULT_FOCUS_SCALE,
+            focusScale: options.focusScale || this.DEFAULT_FOCUS_SCALE,
             showCursor: options.showCursor !== false,
             offset: options.offset || cc.v2(0, 0)
         };
 
+        this.storeBaseScale(node);
         this.items.push(item);
-        this.itemMap[uuid] = item;
+        this.itemMap[node.uuid] = item;
         this.ensureFocus();
     }
 
-    public static unregister(target: cc.Node | any) {
-        let node = this.resolveNode(target);
+    public static unregister(node: cc.Node) {
         if (!node) return;
         delete this.scopeMap[node.uuid];
-        for (let i = this.items.length - 1; i >= 0; i--) {
-            if (this.items[i].node == node) {
-                this.removeItemAt(i);
-            }
+        let item = this.itemMap[node.uuid];
+        if (item) {
+            let idx = this.items.indexOf(item);
+            if (idx >= 0) this.removeItemAt(idx);
         }
         this.ensureFocus();
     }
@@ -79,39 +82,50 @@ export default class FocusManager {
     public static unregisterByRoot(root: cc.Node) {
         if (!root) return;
         for (let i = this.items.length - 1; i >= 0; i--) {
-            let item = this.items[i];
-            if (this.isChildOf(item.node, root)) {
-                delete this.scopeMap[item.node.uuid];
-                this.removeItemAt(i);
+            let cur = this.items[i].node;
+            while (cur) {
+                if (cur == root) {
+                    delete this.scopeMap[this.items[i].node.uuid];
+                    this.removeItemAt(i);
+                    break;
+                }
+                cur = cur.parent;
             }
         }
         this.ensureFocus();
     }
 
-    private static unregisterByUuid(uuid: string) {
-        if (!uuid) return;
-        for (let i = this.items.length - 1; i >= 0; i--) {
-            if (this.items[i].node.uuid == uuid) {
-                delete this.scopeMap[uuid];
-                this.removeItemAt(i);
-            }
+    private static storeBaseScale(node: cc.Node) {
+        let anyNode = node as any;
+        if (anyNode[this.BASE_SCALE_KEY] == null) {
+            anyNode[this.BASE_SCALE_KEY] = { x: node.scaleX, y: node.scaleY };
         }
     }
 
+    private static getBaseScale(node: cc.Node): { x: number, y: number } {
+        return ((node as any)[this.BASE_SCALE_KEY] || { x: 1, y: 1 });
+    }
+
     public static registerButtons(root: cc.Node) {
         if (!root) return;
         this.unregisterByRoot(root);
-        this.walk(root, (node: cc.Node) => {
-            if (node instanceof cc.Scene) return;
-            let button = node.getComponent(cc.Button);
-            if (!button) return;
-            this.register(node, {
-                scopeId: this.activeScopeId,
-                focusScale: this.DEFAULT_FOCUS_SCALE,
-                onClick: () => this.invokeButton(button)
-            });
-        });
-
+        let walk = (node: cc.Node) => {
+            // Scene 节点自身不注册，但必须遍历其子节点
+            if (!(node instanceof cc.Scene)) {
+                let button = node.getComponent(cc.Button);
+                if (button) {
+                    this.register(node, {
+                        scopeId: this.activeScopeId,
+                        focusScale: this.DEFAULT_FOCUS_SCALE,
+                        onClick: () => this.invokeButton(button)
+                    });
+                }
+            }
+            for (let i = 0; i < node.childrenCount; i++) {
+                walk(node.children[i]);
+            }
+        };
+        walk(root);
         this.ensureFocus();
     }
 
@@ -184,10 +198,70 @@ export default class FocusManager {
         this.currentNodeUuid = "";
         this.scopes = [];
         this.activeScopeId = "";
+        if (this.visualLayer) {
+            this.visualLayer.dispose();
+            this.visualLayer = null;
+        }
         this.emitFocusChanged(null, old);
     }
 
-    public static focus(target: string | cc.Node, silent: boolean = false): boolean {
+    // ========================================================================
+    // 视觉层管理（FocusVisualLayer 由 FocusManager 统一管理）
+    // ========================================================================
+
+    /** 显示/隐藏导航手指 */
+    public static setCursorVisible(visible: boolean): void {
+        this._cursorVisible = visible;
+        if (this.visualLayer) {
+            if (visible) {
+                const current = this.getCurrentFocusItem();
+                this.visualLayer.onFocusChanged(current);
+            } else {
+                this.visualLayer.hide();
+            }
+        }
+    }
+
+    /** 导航手指是否可见 */
+    public static isCursorVisible(): boolean {
+        return this._cursorVisible;
+    }
+
+    /** 初始化焦点视觉层 */
+    public static initVisualLayer(): void {
+        if (this.visualLayer) {
+            this.visualLayer.dispose();
+            this.visualLayer = null;
+        }
+        const scene = cc.director.getScene();
+        if (!scene) {
+            console.warn("[FocusManager] Cannot init visual layer: scene is null, will retry next frame");
+            setTimeout(() => this.initVisualLayer(), 0);
+            return;
+        }
+
+        this.visualLayer = new FocusVisualLayer(scene, { style: this._focusStyle, zIndex: this._focusZIndex });
+
+        // 创建后立即同步当前焦点状态
+        const current = this.getCurrentFocusItem();
+        if (current) {
+            this.visualLayer.onFocusChanged(current);
+        }
+    }
+
+    /** 设置焦点样式 */
+    public static setFocusStyle(style: FingerStyle): void {
+        this._focusStyle = style;
+        if (this.visualLayer) this.visualLayer.setStyle(style);
+    }
+
+    /** 设置焦点视觉层级 */
+    public static setFocusZIndex(z: number): void {
+        this._focusZIndex = z;
+        if (this.visualLayer) this.visualLayer.setZIndex(z);
+    }
+
+    public static focus(target: string | cc.Node): boolean {
         this.cleanup();
         if (!target) return false;
         let uuid = typeof target == "string" ? target : target.uuid;
@@ -196,11 +270,9 @@ export default class FocusManager {
 
         let previous: FocusRuntimeItem | null = this.getCurrentFocusItem();
         if (uuid == this.currentNodeUuid && uuid) {
-            let current = this.getCurrentFocusItem();
-            if (current) {
-                this.setFocusVisual(current, true);
-                // 总是触发位置更新，即使静默模式也要更新视觉位置
-                this.emitFocusChanged(current, previous || current);
+            if (previous) {
+                this.setFocusVisual(previous, true);
+                this.emitFocusChanged(previous, previous);
             }
             return true;
         }
@@ -212,7 +284,6 @@ export default class FocusManager {
             if (scope) scope.lastNodeUuid = current.node.uuid;
             this.setFocusVisual(current, true);
         }
-        // 总是触发位置更新，确保视觉层收到通知
         this.emitFocusChanged(current, previous);
         return true;
     }
@@ -225,24 +296,27 @@ export default class FocusManager {
             return !!this.getCurrentFocusItem();
         }
 
-        let vector = this.getDirectionVector(direction);
         let currentCenter = this.getWorldCenter(current.node).add(current.offset);
         let best: FocusRuntimeItem | null = null;
-        let bestScore = Number.MAX_VALUE;
+        let bestDist = Infinity;
 
         for (let i = 0; i < this.items.length; i++) {
             let item = this.items[i];
             if (item == current || !this.isItemActive(item) || !this.isInActiveScope(item)) continue;
+
             let center = this.getWorldCenter(item.node).add(item.offset);
             let dx = center.x - currentCenter.x;
             let dy = center.y - currentCenter.y;
-            if (vector.x != 0 && dx * vector.x <= 0) continue;
-            if (vector.y != 0 && dy * vector.y <= 0) continue;
-            let primary = vector.x != 0 ? Math.abs(dx) : Math.abs(dy);
-            let secondary = vector.x != 0 ? Math.abs(dy) : Math.abs(dx);
-            let score = primary + secondary * 2;
-            if (score < bestScore) {
-                bestScore = score;
+
+            // 必须在目标方向一侧（Cocos Y 轴向上递增）
+            if (direction === KeyCode.Left && dx >= 0) continue;
+            if (direction === KeyCode.Right && dx <= 0) continue;
+            if (direction === KeyCode.Up && dy <= 0) continue;    // 上方：dy > 0
+            if (direction === KeyCode.Down && dy >= 0) continue;  // 下方：dy < 0
+
+            let dist = this.navDistance(dx, dy, direction);
+            if (dist < bestDist) {
+                bestDist = dist;
                 best = item;
             }
         }
@@ -251,22 +325,33 @@ export default class FocusManager {
             this.focus(best.node.uuid);
             return true;
         }
-        return this.moveByOrder(direction == "left" || direction == "down" ? -1 : 1);
+        return this.moveByOrder(direction === KeyCode.Left || direction === KeyCode.Down ? -1 : 1);
+    }
+
+    /** 方向加权距离：对垂直于移动方向的分量加重惩罚，导航更精准 */
+    private static navDistance(dx: number, dy: number, direction: KeyCode): number {
+        switch (direction) {
+            case KeyCode.Left:
+            case KeyCode.Right:
+                // 水平移动：垂直偏差 * 3
+                return Math.sqrt(dx * dx + dy * dy * this.PERP_WEIGHT);
+            case KeyCode.Up:
+            case KeyCode.Down:
+                // 垂直移动：水平偏差 * 3
+                return Math.sqrt(dx * dx * this.PERP_WEIGHT + dy * dy);
+            default:
+                return Math.sqrt(dx * dx + dy * dy);
+        }
     }
 
     public static confirm(): boolean {
-        this.ensureFocus();
         let item = this.getCurrentFocusItem();
-        if (!item) return false;
-        if (item.onClick) {
-            item.onClick();
-            return true;
-        }
-        let focusItem = item.node.getComponent("FocusItem") as any;
-        if (focusItem && focusItem.onConfirm) {
-            focusItem.onConfirm();
-            return true;
+        if (!item) {
+            this.ensureFocus();
+            item = this.getCurrentFocusItem();
+            if (!item) return false;
         }
+        if (item.onClick) return (item.onClick(), true);
         this.invokeButton(item.node.getComponent(cc.Button));
         return true;
     }
@@ -295,9 +380,8 @@ export default class FocusManager {
 
     private static setFocusVisual(item: FocusRuntimeItem, focused: boolean, immediate: boolean = false) {
         if (!item || !item.node || !item.node.isValid) return;
-        this.setButtonSpriteVisual(item, focused);
         item.node.stopActionByTag(this.FOCUS_SCALE_ACTION_TAG);
-        let baseScale = this.getNodeBaseScale(item.node);
+        let baseScale = this.getBaseScale(item.node);
         let targetScaleX = focused ? baseScale.x * item.focusScale : baseScale.x;
         let targetScaleY = focused ? baseScale.y * item.focusScale : baseScale.y;
         if (immediate) {
@@ -311,20 +395,6 @@ export default class FocusManager {
         if (!focused && item.onBlur) item.onBlur();
     }
 
-    private static setButtonSpriteVisual(item: FocusRuntimeItem, focused: boolean) {
-        let button = item.node.getComponent(cc.Button);
-        if (!button || button.transition != cc.Button.Transition.SPRITE) return;
-        let target = button.target || button.node;
-        if (!target || !target.isValid) return;
-        let sprite = target.getComponent(cc.Sprite);
-        if (!sprite) return;
-        let spriteFrame = focused ? (button.hoverSprite || button.pressedSprite) : button.normalSprite;
-        if (spriteFrame) sprite.spriteFrame = spriteFrame;
-    }
-
-    private static _ensureFocusRetry: number = 0;
-    private static readonly _ENSURE_FOCUS_MAX_RETRY = 3;
-
     private static ensureFocus() {
         this.cleanup();
         if (this.getCurrentFocusItem()) return;
@@ -334,37 +404,18 @@ export default class FocusManager {
             let item = this.items[i];
             if (this.isItemActive(item) && this.isInActiveScope(item)) {
                 this.focus(item.node.uuid);
-                this._ensureFocusRetry = 0;
                 return;
             }
         }
-        // 有注册的按钮但暂无活跃节点，可能是节点尚未完全初始化，延迟重试
-        if (this.items.length > 0 && this._ensureFocusRetry < this._ENSURE_FOCUS_MAX_RETRY) {
-            this._ensureFocusRetry++;
-            setTimeout(() => {
-                this.ensureFocus();
-            }, 50);
-            return;
-        }
-        // 超过重试次数/无注册项，清除焦点状态
-        this._ensureFocusRetry = 0;
         this.currentNodeUuid = "";
         this.emitFocusChanged(null, null);
     }
 
     private static moveByOrder(step: number): boolean {
-        let activeItems = [];
-        for (let i = 0; i < this.items.length; i++) {
-            if (this.isItemActive(this.items[i]) && this.isInActiveScope(this.items[i])) activeItems.push(this.items[i]);
-        }
+        let activeItems = this.items.filter(i => this.isItemActive(i) && this.isInActiveScope(i));
         if (activeItems.length <= 0) return false;
-        let index = 0;
-        for (let i = 0; i < activeItems.length; i++) {
-            if (activeItems[i].node.uuid == this.currentNodeUuid) {
-                index = i;
-                break;
-            }
-        }
+        let index = activeItems.findIndex(i => i.node.uuid == this.currentNodeUuid);
+        if (index < 0) index = 0;
         let next = (index + step + activeItems.length) % activeItems.length;
         this.focus(activeItems[next].node.uuid);
         return true;
@@ -412,13 +463,6 @@ export default class FocusManager {
         return cc.v2(box.x + box.width / 2, box.y + box.height / 2);
     }
 
-    private static getDirectionVector(direction: KeyCode): cc.Vec2 {
-        if (direction == KeyCode.Left) return cc.v2(-1, 0);
-        if (direction == KeyCode.Right) return cc.v2(1, 0);
-        if (direction == KeyCode.Up) return cc.v2(0, 1);
-        return cc.v2(0, -1);
-    }
-
     private static invokeButton(button: cc.Button) {
         if (!button || !button.node || !button.node.activeInHierarchy || !button.interactable) return;
         var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
@@ -434,64 +478,17 @@ export default class FocusManager {
     }
 
     private static emitFocusChanged(item: FocusRuntimeItem | null, previous?: FocusRuntimeItem | null) {
+        // 更新焦点视觉层（受 _cursorVisible 开关控制）
+        if (this.visualLayer) {
+            if (this._cursorVisible) {
+                this.visualLayer.onFocusChanged(item);
+            } else {
+                this.visualLayer.hide();
+            }
+        }
+        // 通知外部监听者
         for (let i = 0; i < this.listeners.length; i++) {
             this.listeners[i](item, previous);
         }
     }
-
-    private static resolveNode(target: any): cc.Node | null {
-        if (!target) return null;
-        if (target instanceof cc.Node) return target;
-        return target.node || null;
-    }
-
-    private static resolveComponent(target: any, node: cc.Node): any {
-        if (!target || target instanceof cc.Node) return node.getComponent("FocusItem");
-        return target;
-    }
-
-    private static getNodeBaseScale(node: cc.Node): { x: number, y: number } {
-        let nodeAny: any = node as any;
-        let storedX = nodeAny[this.BASE_SCALE_X_KEY];
-        let storedY = nodeAny[this.BASE_SCALE_Y_KEY];
-        if (this.isValidScale(storedX) && this.isValidScale(storedY)) {
-            return { x: storedX, y: storedY };
-        }
-
-        let baseScale = {
-            x: this.readScale(node, "scaleX"),
-            y: this.readScale(node, "scaleY")
-        };
-        nodeAny[this.BASE_SCALE_X_KEY] = baseScale.x;
-        nodeAny[this.BASE_SCALE_Y_KEY] = baseScale.y;
-        return baseScale;
-    }
-
-    private static readScale(node: cc.Node, key: string): number {
-        let nodeAny: any = node as any;
-        let value = nodeAny[key];
-        if (this.isValidScale(value)) return value;
-        value = nodeAny.scale;
-        return this.isValidScale(value) ? value : 1;
-    }
-
-    private static isValidScale(value: any): boolean {
-        return typeof value == "number" && isFinite(value);
-    }
-
-    private static walk(node: cc.Node, visitor: (node: cc.Node) => void) {
-        visitor(node);
-        for (let i = 0; i < node.childrenCount; i++) {
-            this.walk(node.children[i], visitor);
-        }
-    }
-
-    private static isChildOf(node: cc.Node, root: cc.Node): boolean {
-        let cur = node;
-        while (cur) {
-            if (cur == root) return true;
-            cur = cur.parent;
-        }
-        return false;
-    }
 }