1012 lines
28 KiB
TypeScript
1012 lines
28 KiB
TypeScript
import { ViewManager } from "db://assets/Scripts/Main/Manager/ViewManager";
|
|
import { UITransitionHelper } from "../utils/UITransitionHelper";
|
|
import GameRootUI from "../../Main/Common/GameRootUI";
|
|
import { Node, sys } from "cc";
|
|
import li_EventManager from "../../Main/Common/li_EventManager";
|
|
import { InnerMsgCode } from "../../Main/Config/InnerMsgCode";
|
|
import { ThemePanel } from "../ui/panels/ThemePanel";
|
|
import { GirlListPanel } from "../ui/panels/GirlListPanel";
|
|
import li_BaseView from "../../Main/Common/li_BaseView";
|
|
import { logger } from "db://assets/Scripts/Main/Common/Logger";
|
|
|
|
/**
|
|
* 页面过渡动画类型枚举
|
|
*/
|
|
export enum PageTransitionType {
|
|
NONE = "none",
|
|
SLIDE_LEFT = "slide_left",
|
|
SLIDE_RIGHT = "slide_right",
|
|
SLIDE_UP = "slide_up",
|
|
SLIDE_DOWN = "slide_down",
|
|
FADE = "fade",
|
|
SCALE = "scale",
|
|
}
|
|
|
|
/**
|
|
* NavigationPanel面板类型枚举
|
|
*/
|
|
export enum PanelType {
|
|
THEME = "ThemePanel",
|
|
RANK = "RankPanel",
|
|
PAST_GIRL_LIST = "PastGirlListPanel",
|
|
PERSONAL = "PersonalPanel",
|
|
}
|
|
|
|
/**
|
|
* 页面过渡动画配置接口
|
|
*/
|
|
export interface PageTransitionConfig {
|
|
incomingTransition: PageTransitionType;
|
|
outgoingTransition: PageTransitionType;
|
|
duration?: number;
|
|
simultaneous?: boolean;
|
|
}
|
|
|
|
/**
|
|
* 子面板动画配置接口
|
|
*/
|
|
export interface SubPanelAnimationConfig {
|
|
openAnimation: PageTransitionType;
|
|
closeAnimation: PageTransitionType;
|
|
duration?: number;
|
|
hideBasePanel?: boolean; // 是否隐藏basePanel，用于全屏子面板
|
|
}
|
|
|
|
/**
|
|
* 导航管理器
|
|
*
|
|
* 负责管理游戏中的页面导航和路由，将导航逻辑从业务逻辑中分离出来
|
|
* 统一管理NavigationPanel和其他面板的切换
|
|
*
|
|
* @author AI Chat System
|
|
* @version 1.0.0
|
|
*/
|
|
export class NavigationManager {
|
|
private static _instance: NavigationManager;
|
|
|
|
// NavigationPanel相关属性
|
|
private navigationPanel: any = null; // NavigationPanel实例引用
|
|
private currentActivePanelType: PanelType = PanelType.PAST_GIRL_LIST;
|
|
private currentActivePanel: Node = null; // 初始化为null
|
|
private panelCache: Map<PanelType, Node> = new Map(); // 面板缓存
|
|
|
|
// 选中的角色相关信息
|
|
private selectedGirlId: number = 10002; // 当前选中的角色ID
|
|
private selectedCategoryId: number = -1; // 当前选中的主题ID
|
|
|
|
private static LastSelectGirlID = "LastSelectGirlID";
|
|
|
|
/**
|
|
* 获取NavigationManager的单例实例
|
|
*
|
|
* @returns {NavigationManager} 导航管理器实例
|
|
* @static
|
|
*/
|
|
public static get Instance(): NavigationManager {
|
|
if (!this._instance) {
|
|
this._instance = new NavigationManager();
|
|
|
|
//初始化默认选的girl
|
|
let cacheGirlId = sys.localStorage.getItem(this.LastSelectGirlID);
|
|
if (!cacheGirlId) {
|
|
cacheGirlId = 10016;
|
|
sys.localStorage.setItem(this.LastSelectGirlID, cacheGirlId);
|
|
}
|
|
this._instance.selectedGirlId = Number(cacheGirlId);
|
|
|
|
let cacheCategoryId = sys.localStorage.getItem("LastSelectCategoryId");
|
|
if (!cacheCategoryId) {
|
|
cacheCategoryId = 0;
|
|
sys.localStorage.setItem("LastSelectCategoryId", cacheCategoryId);
|
|
}
|
|
this._instance.selectedCategoryId = cacheCategoryId;
|
|
}
|
|
return this._instance;
|
|
}
|
|
|
|
private constructor() {
|
|
// 初始化事件监听
|
|
this.initEventListeners();
|
|
}
|
|
|
|
/**
|
|
* 初始化事件监听
|
|
*/
|
|
private initEventListeners(): void {
|
|
//
|
|
}
|
|
|
|
/**
|
|
* 注册NavigationPanel实例
|
|
* @param panel NavigationPanel实例
|
|
*/
|
|
public registerNavigationPanel(panel: any): void {
|
|
this.navigationPanel = panel;
|
|
logger.log("[NavigationManager] NavigationPanel registered");
|
|
}
|
|
|
|
/**
|
|
* 统一的面板切换方法
|
|
* @param panelType 目标面板类型
|
|
*/
|
|
public switchToPanel(
|
|
panelType: PanelType,
|
|
force: boolean = false,
|
|
callback: Function = null
|
|
): Node {
|
|
if (!panelType) {
|
|
logger.error("[NavigationManager] switchToPanel: panelType is invalid");
|
|
return null;
|
|
}
|
|
|
|
if (this.currentActivePanelType === panelType && !force) {
|
|
logger.log(
|
|
`[NavigationManager] Already on ${panelType}, skipping switch`
|
|
);
|
|
callback && callback(this.getCurrentActivePanelNode());
|
|
return this.currentActivePanel;
|
|
}
|
|
|
|
if (!this.navigationPanel) {
|
|
logger.warn(
|
|
"[NavigationManager] NavigationPanel not registered, fallback to direct ViewManager call"
|
|
);
|
|
//this.fallbackSwitchPanel(panelType);
|
|
return null;
|
|
}
|
|
|
|
// 切换面板前先关闭所有弹窗
|
|
this.closeAllPopups();
|
|
|
|
// 通知NavigationPanel显示加载状态
|
|
this.navigationPanel.showLoading?.();
|
|
|
|
// 计算动画方向
|
|
const currentIndex = this.getPanelIndex(this.currentActivePanelType);
|
|
const targetIndex = this.getPanelIndex(panelType);
|
|
const isMovingRight = currentIndex < targetIndex;
|
|
|
|
const hideDirection = isMovingRight ? "left" : "right";
|
|
const showDirection = isMovingRight ? "right" : "left";
|
|
|
|
// 清空当前主面板的子页面栈
|
|
if (this.currentActivePanelType) {
|
|
logger.log(
|
|
`[NavigationManager] 切换主面板，清空当前面板的子页面栈: ${this.currentActivePanelType}`
|
|
);
|
|
this.clearSubPanelStack(this.currentActivePanelType, true);
|
|
}
|
|
|
|
// 隐藏当前面板
|
|
if (this.currentActivePanel && this.currentActivePanel.isValid) {
|
|
this.hidePanelWithAnimation(this.currentActivePanel, hideDirection);
|
|
}
|
|
|
|
// 加载并显示目标面板
|
|
this.loadOrGetPanel(panelType, (panel: Node) => {
|
|
this.currentActivePanelType = panelType;
|
|
|
|
// 更新NavigationPanel按钮状态
|
|
this.navigationPanel.updateButtonStates?.(panelType);
|
|
|
|
// 显示面板
|
|
this.showPanelWithAnimation(panel, showDirection, () => {
|
|
this.currentActivePanel = panel;
|
|
this.navigationPanel.hideLoading?.();
|
|
if (callback instanceof Function) callback(panel);
|
|
});
|
|
});
|
|
}
|
|
|
|
// 每个主面板的子页面栈（按打开顺序，最后一个元素是栈顶）
|
|
private subPanelStacks: Map<PanelType, Node[]> = new Map();
|
|
// 子面板到主面板类型的映射
|
|
private subPanelMapping: Map<Node, PanelType> = new Map();
|
|
// 子面板的动画配置
|
|
private subPanelAnimationConfigs: Map<Node, SubPanelAnimationConfig> =
|
|
new Map();
|
|
|
|
// 隐藏的basePanel映射：subPanel -> basePanel
|
|
private hiddenBasePanels: Map<Node, Node> = new Map();
|
|
|
|
// 弹窗管理相关属性
|
|
private popupPanels: Set<Node> = new Set(); // 管理所有打开的弹窗
|
|
|
|
// 动画锁，防止动画中重复操作
|
|
private isAnimating: boolean = false;
|
|
|
|
public openSubPanel(
|
|
panelName: string,
|
|
basePanel: Node,
|
|
data: any = null,
|
|
animationConfig?: SubPanelAnimationConfig
|
|
) {
|
|
if (!panelName) {
|
|
logger.error("[NavigationManager] openSubPanel: panelName is empty");
|
|
return;
|
|
}
|
|
|
|
if (!basePanel || !basePanel.isValid) {
|
|
logger.error("[NavigationManager] openSubPanel: basePanel is invalid");
|
|
return;
|
|
}
|
|
|
|
// 确定主面板类型
|
|
const basePanelType = this.getPanelType(basePanel);
|
|
if (!basePanelType) {
|
|
logger.error(
|
|
`[NavigationManager] 无法确定basePanel类型: ${basePanel.name}`
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 使用默认动画配置
|
|
const defaultConfig: SubPanelAnimationConfig = {
|
|
openAnimation: PageTransitionType.SCALE,
|
|
closeAnimation: PageTransitionType.SCALE,
|
|
duration: 0.3,
|
|
hideBasePanel: false,
|
|
};
|
|
const config = animationConfig || defaultConfig;
|
|
|
|
// 获取当前栈顶的子面板
|
|
const currentTopSubPanel = this.getTopSubPanel(basePanelType);
|
|
|
|
// 如果当前有栈顶子面板，先隐藏它
|
|
if (currentTopSubPanel && currentTopSubPanel.isValid) {
|
|
logger.log(
|
|
`[NavigationManager] 隐藏当前栈顶子面板: ${currentTopSubPanel.name}`
|
|
);
|
|
this.hideSubPanel(currentTopSubPanel);
|
|
}
|
|
|
|
// 如果需要隐藏basePanel，在打开动画前隐藏
|
|
if (config.hideBasePanel && basePanel.active) {
|
|
logger.log(`[NavigationManager] 隐藏basePanel: ${basePanel.name}`);
|
|
basePanel.active = false;
|
|
}
|
|
|
|
const callback = (n: Node) => {
|
|
if (!n || !n.isValid) {
|
|
logger.error(
|
|
"[NavigationManager] openSubPanel: created panel is invalid"
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 初始化栈（如果不存在）
|
|
if (!this.subPanelStacks.has(basePanelType)) {
|
|
this.subPanelStacks.set(basePanelType, []);
|
|
}
|
|
|
|
// 将新子面板推入栈顶
|
|
const stack = this.subPanelStacks.get(basePanelType);
|
|
stack.push(n);
|
|
|
|
// 记录子面板到主面板的映射
|
|
this.subPanelMapping.set(n, basePanelType);
|
|
|
|
// 存储动画配置
|
|
this.subPanelAnimationConfigs.set(n, config);
|
|
|
|
// 如果配置了隐藏basePanel，记录映射关系
|
|
if (config.hideBasePanel) {
|
|
this.hiddenBasePanels.set(n, basePanel);
|
|
logger.log(
|
|
`[NavigationManager] 记录隐藏映射: ${n.name} -> ${basePanel.name}`
|
|
);
|
|
}
|
|
|
|
logger.log(
|
|
`[NavigationManager] 子面板已推入栈顶: ${n.name}, 当前栈深度: ${stack.length}`
|
|
);
|
|
|
|
// 执行打开动画
|
|
this.playSubPanelOpenAnimation(n, config);
|
|
};
|
|
|
|
ViewManager.I.openBundlesView(panelName, data, callback);
|
|
}
|
|
|
|
/**
|
|
* 将过渡类型转换为方向字符串
|
|
*/
|
|
private getDirectionFromTransitionType(
|
|
transitionType: PageTransitionType
|
|
): "left" | "right" | "up" | "down" {
|
|
switch (transitionType) {
|
|
case PageTransitionType.SLIDE_LEFT:
|
|
return "left";
|
|
case PageTransitionType.SLIDE_RIGHT:
|
|
return "right";
|
|
case PageTransitionType.SLIDE_UP:
|
|
return "up";
|
|
case PageTransitionType.SLIDE_DOWN:
|
|
return "down";
|
|
default:
|
|
return "left"; // 默认向左
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 执行子面板打开动画
|
|
*/
|
|
private playSubPanelOpenAnimation(
|
|
panel: Node,
|
|
config: SubPanelAnimationConfig
|
|
): void {
|
|
if (!panel || !panel.isValid) {
|
|
return;
|
|
}
|
|
|
|
const duration = config.duration || 0.3;
|
|
//panel.active = false;
|
|
|
|
switch (config.openAnimation) {
|
|
case PageTransitionType.SCALE:
|
|
UITransitionHelper.scaleIn(panel, duration);
|
|
break;
|
|
case PageTransitionType.FADE:
|
|
UITransitionHelper.fadeIn(panel, duration);
|
|
break;
|
|
case PageTransitionType.SLIDE_UP:
|
|
UITransitionHelper.slideInFromBottom(panel, duration);
|
|
break;
|
|
case PageTransitionType.SLIDE_DOWN:
|
|
UITransitionHelper.slideInFromTop(panel, duration);
|
|
break;
|
|
case PageTransitionType.SLIDE_LEFT:
|
|
UITransitionHelper.slideInFromRight(panel, duration);
|
|
break;
|
|
case PageTransitionType.SLIDE_RIGHT:
|
|
UITransitionHelper.slideInFromLeft(panel, duration);
|
|
break;
|
|
default:
|
|
// 无动画，直接显示
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 执行子面板关闭动画
|
|
*/
|
|
private playSubPanelCloseAnimation(
|
|
panel: Node,
|
|
config: SubPanelAnimationConfig,
|
|
callback?: Function
|
|
): void {
|
|
if (!panel || !panel.isValid) {
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
const duration = config.duration || 0.3;
|
|
|
|
switch (config.closeAnimation) {
|
|
case PageTransitionType.SCALE:
|
|
UITransitionHelper.scaleOut(panel, duration, callback);
|
|
break;
|
|
case PageTransitionType.FADE:
|
|
UITransitionHelper.fadeOut(panel, duration, callback);
|
|
break;
|
|
case PageTransitionType.SLIDE_UP:
|
|
UITransitionHelper.slideOutToTop(panel, duration, callback);
|
|
break;
|
|
case PageTransitionType.SLIDE_DOWN:
|
|
UITransitionHelper.slideOutToBottom(panel, duration, callback);
|
|
break;
|
|
case PageTransitionType.SLIDE_LEFT:
|
|
UITransitionHelper.slideOutToLeft(panel, duration, callback);
|
|
break;
|
|
case PageTransitionType.SLIDE_RIGHT:
|
|
UITransitionHelper.slideOutToRight(panel, duration, callback);
|
|
break;
|
|
default:
|
|
// 无动画，直接执行回调
|
|
callback && callback();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 打开弹窗面板
|
|
* @param panelName 弹窗面板名称
|
|
* @param data 传递的数据
|
|
* @param callback 可选的回调函数
|
|
*/
|
|
public openPopupPanel(
|
|
panelName: string,
|
|
data: any = null,
|
|
callback?: Function
|
|
): void {
|
|
if (!panelName) {
|
|
logger.error("[NavigationManager] openPopupPanel: panelName is empty");
|
|
return;
|
|
}
|
|
|
|
const popupCallback = (panel: Node) => {
|
|
if (!panel || !panel.isValid) {
|
|
logger.error(
|
|
"[NavigationManager] openPopupPanel: created panel is invalid"
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 将弹窗添加到管理集合中
|
|
this.popupPanels.add(panel);
|
|
logger.log(
|
|
`[NavigationManager] Popup panel opened: ${panelName}, total popups: ${this.popupPanels.size}`
|
|
);
|
|
|
|
if (callback) {
|
|
callback(panel);
|
|
}
|
|
};
|
|
|
|
ViewManager.I.openBundlesPopupView(panelName, data, popupCallback);
|
|
}
|
|
|
|
/**
|
|
* 关闭弹窗面板
|
|
* @param panel 要关闭的弹窗节点
|
|
*/
|
|
public closePopupPanel(panel: Node): void {
|
|
if (!panel || !panel.isValid) {
|
|
logger.warn("[NavigationManager] closePopupPanel: panel is invalid");
|
|
return;
|
|
}
|
|
|
|
// 从弹窗管理集合中移除
|
|
if (this.popupPanels.has(panel)) {
|
|
this.popupPanels.delete(panel);
|
|
logger.log(
|
|
`[NavigationManager] Popup panel closed: ${panel.name}, total popups: ${this.popupPanels.size}`
|
|
);
|
|
}
|
|
|
|
// 关闭面板
|
|
try {
|
|
const baseView = panel.getComponent(li_BaseView);
|
|
if (baseView) {
|
|
baseView.close();
|
|
} else {
|
|
panel.destroy();
|
|
}
|
|
} catch (error) {
|
|
logger.error("[NavigationManager] closePopupPanel error:", error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 关闭所有弹窗
|
|
*/
|
|
private closeAllPopups(): void {
|
|
if (this.popupPanels.size === 0) {
|
|
return;
|
|
}
|
|
|
|
logger.log(
|
|
`[NavigationManager] Closing all popups, count: ${this.popupPanels.size}`
|
|
);
|
|
|
|
// 复制Set以避免在迭代过程中修改
|
|
const popupPanelsToClose = Array.from(this.popupPanels);
|
|
|
|
for (const panel of popupPanelsToClose) {
|
|
if (panel && panel.isValid) {
|
|
this.closePopupPanel(panel);
|
|
}
|
|
}
|
|
|
|
// 确保清空集合
|
|
this.popupPanels.clear();
|
|
}
|
|
|
|
/**
|
|
* 获取指定主面板栈顶的子面板
|
|
* @param panelType 主面板类型
|
|
* @returns 栈顶子面板，如果栈为空则返回null
|
|
*/
|
|
private getTopSubPanel(panelType: PanelType): Node | null {
|
|
const stack = this.subPanelStacks.get(panelType);
|
|
if (!stack || stack.length === 0) {
|
|
return null;
|
|
}
|
|
return stack[stack.length - 1];
|
|
}
|
|
|
|
/**
|
|
* 清空指定主面板的子页面栈
|
|
* @param panelType 主面板类型
|
|
* @param withAnimation 是否播放动画
|
|
* @param callback 清空完成后的回调
|
|
*/
|
|
private clearSubPanelStack(
|
|
panelType: PanelType,
|
|
withAnimation: boolean = true,
|
|
callback?: Function
|
|
): void {
|
|
const stack = this.subPanelStacks.get(panelType);
|
|
if (!stack || stack.length === 0) {
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
if (!withAnimation) {
|
|
// 不播放动画，直接销毁所有子面板
|
|
for (let i = stack.length - 1; i >= 0; i--) {
|
|
const subPanel = stack[i];
|
|
if (subPanel && subPanel.isValid) {
|
|
// 清理映射
|
|
this.subPanelMapping.delete(subPanel);
|
|
this.subPanelAnimationConfigs.delete(subPanel);
|
|
this.hiddenBasePanels.delete(subPanel);
|
|
|
|
// 销毁节点
|
|
const baseView = subPanel.getComponent(li_BaseView);
|
|
if (baseView) {
|
|
baseView.close();
|
|
} else {
|
|
subPanel.destroy();
|
|
}
|
|
}
|
|
}
|
|
this.subPanelStacks.delete(panelType);
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
// 播放动画
|
|
let completedCount = 0;
|
|
const totalCount = stack.length;
|
|
|
|
const onAnimationComplete = () => {
|
|
completedCount++;
|
|
if (completedCount >= totalCount) {
|
|
this.subPanelStacks.delete(panelType);
|
|
callback && callback();
|
|
}
|
|
};
|
|
|
|
// 同时播放所有子面板的关闭动画
|
|
for (let i = stack.length - 1; i >= 0; i--) {
|
|
const subPanel = stack[i];
|
|
if (subPanel && subPanel.isValid) {
|
|
// 获取动画配置
|
|
let config = this.subPanelAnimationConfigs.get(subPanel);
|
|
if (!config) {
|
|
config = {
|
|
openAnimation: PageTransitionType.SCALE,
|
|
closeAnimation: PageTransitionType.SCALE,
|
|
duration: 0.2,
|
|
};
|
|
}
|
|
|
|
// 播放关闭动画
|
|
this.playSubPanelCloseAnimation(subPanel, config, () => {
|
|
// 清理映射
|
|
this.subPanelMapping.delete(subPanel);
|
|
this.subPanelAnimationConfigs.delete(subPanel);
|
|
this.hiddenBasePanels.delete(subPanel);
|
|
|
|
// 销毁节点
|
|
const baseView = subPanel.getComponent(li_BaseView);
|
|
if (baseView) {
|
|
baseView.close();
|
|
} else {
|
|
subPanel.destroy();
|
|
}
|
|
|
|
onAnimationComplete();
|
|
});
|
|
} else {
|
|
onAnimationComplete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 显示子面板
|
|
* @param panel 子面板节点
|
|
* @param config 动画配置（可选）
|
|
* @param withAnimation 是否播放打开动画，默认为 true
|
|
*/
|
|
private showSubPanel(
|
|
panel: Node,
|
|
config?: SubPanelAnimationConfig,
|
|
withAnimation: boolean = true
|
|
): void {
|
|
if (!panel || !panel.isValid) {
|
|
return;
|
|
}
|
|
|
|
panel.active = true;
|
|
|
|
if (config && withAnimation) {
|
|
this.playSubPanelOpenAnimation(panel, config);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 隐藏子面板（不销毁）
|
|
* @param panel 子面板节点
|
|
* @param callback 隐藏完成后的回调
|
|
*/
|
|
private hideSubPanel(panel: Node, callback?: Function): void {
|
|
if (!panel || !panel.isValid) {
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
// 直接隐藏，不播放动画（因为会被新面板覆盖）
|
|
panel.active = false;
|
|
callback && callback();
|
|
}
|
|
|
|
public closeSubPanel(
|
|
panel: Node | li_BaseView,
|
|
animationConfig?: SubPanelAnimationConfig
|
|
) {
|
|
if (!panel) {
|
|
logger.warn(
|
|
"[NavigationManager] closeSubPanel: panel is null or undefined"
|
|
);
|
|
return;
|
|
}
|
|
|
|
let panelNode: Node;
|
|
if (panel instanceof Node) {
|
|
panelNode = panel;
|
|
} else {
|
|
panelNode = panel.node;
|
|
}
|
|
|
|
if (!panelNode || !panelNode.isValid) {
|
|
logger.warn("[NavigationManager] closeSubPanel: panelNode is invalid");
|
|
return;
|
|
}
|
|
|
|
// 确定子面板所属的主面板类型
|
|
const basePanelType = this.subPanelMapping.get(panelNode);
|
|
if (!basePanelType) {
|
|
logger.warn(
|
|
`[NavigationManager] closeSubPanel: 无法确定子面板所属的主面板类型: ${panelNode.name}`
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 获取栈
|
|
const stack = this.subPanelStacks.get(basePanelType);
|
|
if (!stack || stack.length === 0) {
|
|
logger.warn(
|
|
`[NavigationManager] closeSubPanel: 栈为空或不存在，无法关闭子面板: ${panelNode.name}`
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 查找子面板在栈中的索引
|
|
const panelIndex = stack.indexOf(panelNode);
|
|
if (panelIndex === -1) {
|
|
logger.warn(
|
|
`[NavigationManager] closeSubPanel: 子面板不在栈中: ${panelNode.name}`
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 从栈中移除
|
|
stack.splice(panelIndex, 1);
|
|
logger.log(
|
|
`[NavigationManager] 从栈中移除子面板: ${panelNode.name}, 剩余栈深度: ${stack.length}`
|
|
);
|
|
|
|
// 获取动画配置（优先使用传入的配置，然后使用存储的配置，最后使用默认配置）
|
|
let config = animationConfig;
|
|
if (!config && this.subPanelAnimationConfigs.has(panelNode)) {
|
|
config = this.subPanelAnimationConfigs.get(panelNode);
|
|
}
|
|
if (!config) {
|
|
config = {
|
|
openAnimation: PageTransitionType.SCALE,
|
|
closeAnimation: PageTransitionType.SCALE,
|
|
duration: 0.3,
|
|
hideBasePanel: false,
|
|
};
|
|
}
|
|
|
|
// 检查是否需要恢复显示basePanel或显示下一层子面板
|
|
const shouldRestoreBasePanel =
|
|
config.hideBasePanel && this.hiddenBasePanels.has(panelNode);
|
|
const basePanel = shouldRestoreBasePanel
|
|
? this.hiddenBasePanels.get(panelNode)
|
|
: null;
|
|
|
|
// 获取新的栈顶子面板（如果有）
|
|
const newTopSubPanel = this.getTopSubPanel(basePanelType);
|
|
|
|
// 执行关闭动画
|
|
this.playSubPanelCloseAnimation(panelNode, config, () => {
|
|
// 清理映射
|
|
this.subPanelMapping.delete(panelNode);
|
|
this.subPanelAnimationConfigs.delete(panelNode);
|
|
if (this.hiddenBasePanels.has(panelNode)) {
|
|
this.hiddenBasePanels.delete(panelNode);
|
|
}
|
|
|
|
// 销毁或关闭panel
|
|
try {
|
|
if (panel instanceof Node) {
|
|
panel.destroy();
|
|
} else {
|
|
panel.close();
|
|
}
|
|
} catch (error) {
|
|
logger.error("[NavigationManager] closeSubPanel error:", error);
|
|
}
|
|
|
|
// 关闭动画完成后，决定显示什么
|
|
if (newTopSubPanel && newTopSubPanel.isValid) {
|
|
// 栈中还有子面板，显示新的栈顶（不播放动画，直接显示）
|
|
logger.log(
|
|
`[NavigationManager] 显示新的栈顶子面板（无动画）: ${newTopSubPanel.name}`
|
|
);
|
|
const newTopConfig = this.subPanelAnimationConfigs.get(newTopSubPanel);
|
|
this.showSubPanel(newTopSubPanel, newTopConfig, false); // 传入 false，不播放动画
|
|
} else if (shouldRestoreBasePanel && basePanel && basePanel.isValid) {
|
|
// 栈已空，且之前隐藏了basePanel，恢复显示basePanel
|
|
logger.log(`[NavigationManager] 恢复显示basePanel: ${basePanel.name}`);
|
|
basePanel.active = true;
|
|
} else {
|
|
// 栈已空，且没有隐藏basePanel，确保basePanel可见
|
|
const cachedBasePanel = this.panelCache.get(basePanelType);
|
|
if (
|
|
cachedBasePanel &&
|
|
cachedBasePanel.isValid &&
|
|
!cachedBasePanel.active
|
|
) {
|
|
logger.log(
|
|
`[NavigationManager] 确保basePanel可见: ${cachedBasePanel.name}`
|
|
);
|
|
cachedBasePanel.active = true;
|
|
}
|
|
}
|
|
|
|
// 如果栈完全清空，删除映射
|
|
if (stack.length === 0) {
|
|
this.subPanelStacks.delete(basePanelType);
|
|
logger.log(
|
|
`[NavigationManager] 子页面栈已清空，删除映射: ${basePanelType}`
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 获取面板索引（用于动画方向计算）
|
|
*/
|
|
private getPanelIndex(panelType: PanelType): number {
|
|
switch (panelType) {
|
|
case PanelType.THEME:
|
|
return 0;
|
|
case PanelType.RANK:
|
|
return 1;
|
|
case PanelType.PAST_GIRL_LIST:
|
|
return 2;
|
|
case PanelType.PERSONAL:
|
|
return 3;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
private getPanelType(node: Node): PanelType {
|
|
if (!node || !node.isValid) {
|
|
logger.warn("[NavigationManager] getPanelType: node is invalid");
|
|
return null;
|
|
}
|
|
|
|
switch (node.name) {
|
|
case "ThemePanel":
|
|
return PanelType.THEME;
|
|
case "RankPanel":
|
|
return PanelType.RANK;
|
|
case "PastGirlListPanel":
|
|
return PanelType.PAST_GIRL_LIST;
|
|
case "PersonalPanel":
|
|
return PanelType.PERSONAL;
|
|
default:
|
|
logger.warn(
|
|
`[NavigationManager] Unknown panel type for node: ${node.name}`
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取面板名称
|
|
*/
|
|
private getPanelName(panelType: PanelType): string {
|
|
return panelType as string;
|
|
}
|
|
|
|
/**
|
|
* 获取面板数据
|
|
*/
|
|
private getPanelData(panelType: PanelType): any {
|
|
// 所有主页面都不需要特殊数据
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 加载或获取面板
|
|
*/
|
|
private loadOrGetPanel(
|
|
panelType: PanelType,
|
|
callback: (panel: Node) => void
|
|
) {
|
|
// 检查缓存
|
|
if (this.panelCache.has(panelType)) {
|
|
const cachedPanel = this.panelCache.get(panelType);
|
|
if (cachedPanel && cachedPanel.isValid) {
|
|
// 注意：子面板的清理已经在 switchToPanel 中通过 clearSubPanelStack 完成了
|
|
// 这里不需要再清理
|
|
|
|
// 特殊处理：主题面板刷新（避免重复调用Show）
|
|
if (panelType === PanelType.THEME) {
|
|
const themePanel = cachedPanel.getComponent(ThemePanel);
|
|
if (themePanel) {
|
|
// 不在这里调用Show()，因为ThemePanel已经有加载状态保护
|
|
// 只在必要时调用onHide()确保子页面状态正确
|
|
if (typeof themePanel.onHide === "function") {
|
|
logger.log("[NavigationManager] 确保主题面板子页面状态正确");
|
|
themePanel.onHide();
|
|
}
|
|
}
|
|
}
|
|
callback(cachedPanel);
|
|
return;
|
|
} else {
|
|
this.panelCache.delete(panelType);
|
|
}
|
|
}
|
|
|
|
// 加载新面板
|
|
const panelName = this.getPanelName(panelType);
|
|
const openData = this.getPanelData(panelType);
|
|
|
|
ViewManager.I.openBundlesView(panelName, openData, (panel: Node) => {
|
|
if (panel && panel.isValid) {
|
|
this.panelCache.set(panelType, panel);
|
|
callback(panel);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 隐藏面板动画
|
|
*/
|
|
private hidePanelWithAnimation(
|
|
panel: Node,
|
|
direction: "left" | "right" | "up" | "down",
|
|
callback?: Function
|
|
) {
|
|
if (!panel || !panel.isValid) {
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
// 注意：子面板的清理已经在 switchToPanel 中通过 clearSubPanelStack 完成了
|
|
// 这里只需要播放主面板的隐藏动画
|
|
|
|
if (!panel.active) panel.active = true;
|
|
|
|
const animationCallback = () => {
|
|
panel.active = false;
|
|
callback && callback();
|
|
};
|
|
|
|
// 主面板动画
|
|
switch (direction) {
|
|
case "left":
|
|
UITransitionHelper.slideOutToLeft(panel, 0.3, animationCallback);
|
|
break;
|
|
case "right":
|
|
UITransitionHelper.slideOutToRight(panel, 0.3, animationCallback);
|
|
break;
|
|
case "up":
|
|
UITransitionHelper.slideOutToTop(panel, 0.3, animationCallback);
|
|
break;
|
|
case "down":
|
|
UITransitionHelper.slideOutToBottom(panel, 0.3, animationCallback);
|
|
break;
|
|
default:
|
|
// 默认左侧滑出
|
|
UITransitionHelper.slideOutToLeft(panel, 0.3, animationCallback);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 显示面板动画
|
|
*/
|
|
private showPanelWithAnimation(
|
|
panel: Node,
|
|
direction: "left" | "right" | "up" | "down",
|
|
callback?: Function
|
|
) {
|
|
if (!panel || !panel.isValid) {
|
|
callback && callback();
|
|
return;
|
|
}
|
|
|
|
panel.active = true;
|
|
panel.getComponent(li_BaseView);
|
|
|
|
switch (direction) {
|
|
case "left":
|
|
UITransitionHelper.slideInFromLeft(panel, 0.3, callback);
|
|
break;
|
|
case "right":
|
|
UITransitionHelper.slideInFromRight(panel, 0.3, callback);
|
|
break;
|
|
case "up":
|
|
UITransitionHelper.slideInFromTop(panel, 0.3, callback);
|
|
break;
|
|
case "down":
|
|
UITransitionHelper.slideInFromBottom(panel, 0.3, callback);
|
|
break;
|
|
default:
|
|
// 默认从右侧滑入
|
|
UITransitionHelper.slideInFromRight(panel, 0.3, callback);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取当前激活的面板类型
|
|
*/
|
|
public getCurrentActivePanel(): PanelType {
|
|
return this.currentActivePanelType;
|
|
}
|
|
|
|
/**
|
|
* 获取当前激活的面板节点
|
|
*/
|
|
public getCurrentActivePanelNode(): Node {
|
|
return this.currentActivePanel;
|
|
}
|
|
|
|
/**
|
|
* 设置选中的角色ID
|
|
* @param girlId 角色ID
|
|
*/
|
|
public setSelectedGirlId(girlId: number): void {
|
|
this.selectedGirlId = girlId;
|
|
sys.localStorage.setItem(NavigationManager.LastSelectGirlID, girlId);
|
|
logger.log("[NavigationManager] Selected girl ID set to:", girlId);
|
|
}
|
|
|
|
/**
|
|
* 获取当前选中的角色ID
|
|
* @returns 当前选中的角色ID
|
|
*/
|
|
public getSelectedGirlId(): number {
|
|
return this.selectedGirlId;
|
|
}
|
|
|
|
/**
|
|
* 设置选中的主题ID
|
|
* @param themeId 主题ID
|
|
*/
|
|
public setSelectedCategoryId(themeId: number): void {
|
|
this.selectedCategoryId = themeId;
|
|
logger.log("[NavigationManager] Selected theme ID set to:", themeId);
|
|
}
|
|
|
|
/**
|
|
* 获取当前选中的主题ID
|
|
* @returns 当前选中的主题ID
|
|
*/
|
|
public getSelectedCategoryId(): number {
|
|
return this.selectedCategoryId;
|
|
}
|
|
}
|