janing/rougelike-demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构NetManager支持MessagePair，新增TSRPCWsClient。

Browse Source
This commit is contained in:
janing
2025-12-18 13:25:04 +08:00
parent c12e439add
commit fb940452db
41 changed files with 976 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
client/assets/scripts/Framework/Net/LoginProtocol.ts
View File

@@ -1,49 +0,0 @@
/**
* 登录协议类型定义
*
* 注意: 这是临时定义,实际项目中应该通过 npm run sync-shared
* 从服务端同步完整的协议定义到 Shared 目录
*/
/**
* 登录请求
*/
export interface ReqLogin {
/** 账号 */
account: string;
/** 密码 (可选) */
password?: string;
}
/**
* 登录响应
*/
export interface ResLogin {
/** 是否成功 */
success: boolean;
/** 消息 */
message?: string;
/** 玩家信息 */
player?: {
/** 玩家ID */
id: string;
/** 玩家名称 */
name: string;
/** 位置 */
position: { x: number; y: number; z: number };
/** 出生点 */
spawnPoint: { x: number; y: number; z: number };
/** 生命值 */
hp: number;
/** 最大生命值 */
maxHp: number;
/** 是否存活 */
isAlive: boolean;
/** 创建时间 */
createdAt: number;
/** 最后登录时间 */
lastLoginAt: number;
};
/** 是否新玩家 */
isNewPlayer?: boolean;
}

9
client/assets/scripts/Framework/Net/LoginProtocol.ts.meta
View File

@@ -1,9 +0,0 @@
{
"ver": "4.0.24",
"importer": "typescript",
"imported": true,
"uuid": "b5331a2b-20fa-4653-8013-deb54bad8d2e",
"files": [],
"subMetas": {},
"userData": {}
}

29
client/assets/scripts/Framework/Net/NetConfig.ts
View File

@@ -1,29 +1,48 @@
/**
* 网络协议类型
*/
export enum NetProtocolType {
/** HTTP/HTTPS 协议 */
Http = "http",
/** WebSocket 协议 */
WebSocket = "websocket"
}
/**
* 网络配置接口
*/
export interface NetConfig {
/** 服务器地址 */
serverUrl: string;
/** 网络协议类型 默认 Http */
protocolType?: NetProtocolType;
/** 超时时间(ms) 默认 30000 */
timeout?: number;
/** 是否自动重连 默认 true */
autoReconnect?: boolean;
/** 重连间隔(ms) 默认 3000 */
reconnectInterval?: number;
/** 最大重连次数 默认 5 */
maxReconnectTimes?: number;
/** 是否使用JSON格式 默认 true */
json?: boolean;
}
/**
* 默认网络配置
*/
export const DefaultNetConfig: Partial<NetConfig> = {
protocolType: NetProtocolType.Http,
timeout: 30000,
autoReconnect: true,
reconnectInterval: 3000,
maxReconnectTimes: 5
maxReconnectTimes: 5,
json: true
};

15
client/assets/scripts/Framework/Net/NetEvent.ts
View File

@@ -2,24 +2,27 @@
* 网络事件定义
*/
export enum NetEvent {
/** 正在连接 */
Connecting = "net_connecting",
/** 连接成功 */
Connected = "net_connected",
/** 连接断开 */
Disconnected = "net_disconnected",
/** 正在重连 */
Reconnecting = "net_reconnecting",
/** 重连成功 */
ReconnectSuccess = "net_reconnect_success",
/** 重连失败 */
ReconnectFailed = "net_reconnect_failed",
/** 网络错误 */
Error = "net_error",
/** 连接超时 */
Timeout = "net_timeout"
}

249
client/assets/scripts/Framework/Net/NetManager.ts
View File

@@ -1,33 +1,36 @@
import { NetConfig, DefaultNetConfig } from './NetConfig';
import { MessagePair, MessagePairRegistry } from '../../App/Msg/MessagePairBase';
import { DefaultNetConfig, NetConfig, NetProtocolType } from './NetConfig';
import { NetEvent } from './NetEvent';
import { PlatformAdapter, ClientConfig } from './PlatformAdapter';
import { ClientConfig, PlatformAdapter } from './PlatformAdapter';
import { INetClient } from './WebSocketClient';
/**
* 网络管理器单例
* 负责管理网络连接和消息通信
* 支持 HTTP 和 WebSocket 两种协议
*/
export class NetManager {
private static _instance: NetManager | null = null;
/** TSRPC Client 实例 (HttpClient) */
private _client: any = null;
/** TSRPC Client 实例 (HttpClient 或 WsClient) */
private _client: INetClient | null = null;
/** 是否已连接 */
private _isConnected: boolean = false;
/** 网络配置 */
private _config: NetConfig | null = null;
/** 重连计数 */
private _reconnectCount: number = 0;
/** 重连定时器 */
private _reconnectTimer: any = null;
/** 事件监听器 */
private _eventListeners: Map<string, Function[]> = new Map();
private constructor() {}
private constructor() { }
/**
* 获取单例实例
@@ -58,6 +61,7 @@ export class NetManager {
} as NetConfig;
console.log('[NetManager] Initialized with config:', this._config);
console.log('[NetManager] Protocol:', this._config.protocolType);
console.log('[NetManager] Platform:', PlatformAdapter.getPlatformInfo());
}
@@ -66,46 +70,56 @@ export class NetManager {
*/
async connect(): Promise<boolean> {
try {
if (!this._config) {
console.error('[NetManager] Config not set, please call init() first');
return false;
}
console.log('[NetManager] Connecting to server:', this._config.serverUrl);
// 创建客户端配置
const clientConfig: ClientConfig = {
server: this._config.serverUrl,
json: true,
timeout: this._config.timeout
protocolType: this._config.protocolType,
json: this._config.json,
timeout: this._config.timeout,
};
// 根据平台创建对应的客户端
// 根据平台和协议类型创建对应的客户端
this._client = PlatformAdapter.createClient(clientConfig);
// HttpClient 不需要显式连接,创建即可使用
// 如果未来需要 WebSocket 支持,可以在这里添加 connect() 调用
// 如果是 WebSocket 客户端，需要显式连接
if (this._config.protocolType === NetProtocolType.WebSocket && this._client.connect) {
this.emit(NetEvent.Connecting);
const result = await this._client.connect();
if (!result.isSucc) {
console.error('[NetManager] WebSocket connection failed:', result.errMsg);
this.emit(NetEvent.Error, result.errMsg);
// 尝试重连
if (this._config.autoReconnect) {
this.scheduleReconnect();
}
return false;
}
}
this._isConnected = true;
this._reconnectCount = 0;
this.emit(NetEvent.Connected);
console.log('[NetManager] Client created successfully');
// client 可能不需要显式连接
// 对于 WsClient 需要调用 connect()
this._isConnected = true;
this._reconnectCount = 0;
this.emit(NetEvent.Connected);
console.log('[NetManager] Connected successfully');
return true;
} catch (error) {
console.error('[NetManager] Connection failed:', error);
this.emit(NetEvent.Error, error);
// 尝试重连
if (this._config.autoReconnect) {
if (this._config?.autoReconnect) {
this.scheduleReconnect();
}
return false;
}
}
@@ -114,26 +128,26 @@ export class NetManager {
* 断开连接
*/
disconnect(): void {
if (!this._isConnected) {
if (!this._isConnected || !this._client) {
return;
}
// HttpClient 无需显式断开连接
// 如果使用 WebSocket，可以在这里调用 disconnect()
this._isConnected = false;
this._client = null;
if(this._reconnectTimer){
console.log('[NetManager] Disconnecting...');
// 清除重连定时器
if (this._reconnectTimer) {
clearTimeout(this._reconnectTimer);
this._reconnectTimer = null;
}
// TODO: 调用客户端的断开连接方法
if (this._client && typeof this._client.disconnect === 'function') {
// 如果是 WebSocket 客户端，调用断开连接方法
if (this._client.disconnect) {
this._client.disconnect();
}
this._isConnected = false;
this._client = null;
this.emit(NetEvent.Disconnected);
console.log('[NetManager] Disconnected');
}
@@ -151,13 +165,12 @@ export class NetManager {
try {
console.log(`[NetManager] Calling API: ${apiName}`, req);
// TODO: 根据实际的协议定义调用 API
const result = await this._client.callApi(apiName, req);
if (result.isSucc) {
console.log(`[NetManager] API ${apiName} success:`, result.res);
return result.res;
return result.res as Res;
} else {
console.error(`[NetManager] API ${apiName} failed:`, result.err);
return null;
@@ -170,7 +183,7 @@ export class NetManager {
}
/**
* 监听消息
* 监听消息 (仅支持 WebSocket)
* @param msgName 消息名称
* @param handler 处理函数
*/
@@ -180,16 +193,91 @@ export class NetManager {
return;
}
console.log(`[NetManager] Listening message: ${msgName}`);
// TODO: 根据实际的 TSRPC 客户端实现监听消息
if (typeof this._client.listenMsg === 'function') {
this._client.listenMsg(msgName, handler);
if (!this._client.listenMsg) {
console.warn('[NetManager] Message listening not supported for HTTP client');
return;
}
console.log(`[NetManager] Listening message: ${msgName}`);
this._client.listenMsg(msgName, handler);
}
/**
* 发送消息
* 取消监听消息 (仅支持 WebSocket)
* @param msgName 消息名称
* @param handler 处理函数(可选,不传则取消所有该消息的监听)
*/
unlistenMsg(msgName: string, handler?: Function): void {
if (!this._client) {
console.error('[NetManager] Client not initialized');
return;
}
if (!this._client.unlistenMsg) {
console.warn('[NetManager] Message listening not supported for HTTP client');
return;
}
console.log(`[NetManager] Unlisten message: ${msgName}`);
this._client.unlistenMsg(msgName, handler);
}
/**
* 发送消息并等待响应 (基于消息对系统)
* @param messagePair 消息对实例
* @param requestData 请求消息内容
* @returns Promise<响应消息>
*/
async callMsg<TReq, TRes>(messagePair: MessagePair<TReq, TRes>, requestData: TReq): Promise<TRes | null> {
if (!this._isConnected || !this._client) {
console.error('[NetManager] Not connected');
return null;
}
const requestName = messagePair.requestName;
const responseName = messagePair.responseName;
// 验证请求消息格式
if (!messagePair.isValidRequest(requestData)) {
console.error(`[NetManager] Invalid request data for ${requestName}:`, requestData);
return null;
}
console.log(`[NetManager] Calling message: ${requestName} -> ${responseName}`, requestData);
return new Promise<TRes | null>((resolve, reject) => {
// 创建一次性响应处理器
const responseHandler = (response: TRes) => {
// 验证响应消息格式
if (!messagePair.isValidResponse(response)) {
return;
}
// 取消监听
this.unlistenMsg(responseName, responseHandler);
// 返回响应
console.log(`[NetManager] Received response for ${requestName}:`, response);
resolve(response);
};
// 监听响应
this.listenMsg(responseName, responseHandler);
// 发送请求消息
this.sendMsg(requestName, requestData);
// 设置超时处理
const timeout = this._config?.timeout || 30000;
setTimeout(() => {
this.unlistenMsg(responseName, responseHandler);
console.error(`[NetManager] Request timeout for ${requestName}`);
resolve(null);
}, timeout);
});
}
/**
* 发送消息 (仅支持 WebSocket)
* @param msgName 消息名称
* @param msg 消息内容
*/
@@ -199,12 +287,13 @@ export class NetManager {
return;
}
console.log(`[NetManager] Sending message: ${msgName}`, msg);
// TODO: 根据实际的 TSRPC 客户端实现发送消息
if (typeof this._client.sendMsg === 'function') {
this._client.sendMsg(msgName, msg);
if (!this._client.sendMsg) {
console.warn('[NetManager] Message sending not supported for HTTP client');
return;
}
console.log(`[NetManager] Sending message: ${msgName}`, msg);
this._client.sendMsg(msgName, msg);
}
/**
@@ -223,9 +312,9 @@ export class NetManager {
this._reconnectCount++;
console.log(`[NetManager] Scheduling reconnect (${this._reconnectCount}/${this._config.maxReconnectTimes})...`);
this.emit(NetEvent.Reconnecting, this._reconnectCount);
this._reconnectTimer = setTimeout(() => {
this.reconnect();
}, this._config.reconnectInterval || 3000);
@@ -236,9 +325,9 @@ export class NetManager {
*/
private async reconnect(): Promise<void> {
console.log('[NetManager] Reconnecting...');
const success = await this.connect();
if (success) {
this.emit(NetEvent.ReconnectSuccess);
} else if (this._config?.autoReconnect) {
@@ -301,7 +390,41 @@ export class NetManager {
/**
* 获取客户端实例
*/
get client(): any {
get client(): INetClient | null {
return this._client;
}
/**
* 获取协议类型
*/
get protocolType(): NetProtocolType | undefined {
return this._config?.protocolType;
}
/**
* 判断是否为 WebSocket 连接
*/
get isWebSocket(): boolean {
return this._config?.protocolType === NetProtocolType.WebSocket;
}
/**
* 判断是否为 HTTP 连接
*/
get isHttp(): boolean {
return this._config?.protocolType === NetProtocolType.Http;
}
/**
* 获取所有已注册的消息对信息
* @returns 消息对列表
*/
getMessagePairs(): { requestName: string; responseName: string }[] {
const registry = MessagePairRegistry.getInstance();
return registry.getAllPairs().map(pair => ({
requestName: pair.requestName,
responseName: pair.responseName
}));
}
}

77
client/assets/scripts/Framework/Net/PlatformAdapter.ts
View File

@@ -1,7 +1,9 @@
import { sys } from 'cc';
// 使用别名导入避免命名冲突
import { BaseServiceType, HttpClient as HttpClientBrowser } from 'tsrpc-browser';
import { HttpClient as HttpClientMiniapp } from 'tsrpc-miniapp';
import { BaseServiceType, HttpClient as HttpClientBrowser, WsClient as WsClientBrowser } from 'tsrpc-browser';
import { HttpClient as HttpClientMiniapp, WsClient as WsClientMiniapp } from 'tsrpc-miniapp';
import { NetProtocolType } from './NetConfig';
import { INetClient, WebSocketClientWrapper } from './WebSocketClient';
/**
* 平台类型枚举
@@ -9,10 +11,10 @@ import { HttpClient as HttpClientMiniapp } from 'tsrpc-miniapp';
export enum PlatformType {
/** 浏览器平台 */
Browser = "browser",
/** 小程序平台 (微信、抖音、QQ等) */
MiniApp = "miniapp",
/** 未知平台 */
Unknown = "unknown"
}
@@ -23,22 +25,29 @@ export enum PlatformType {
export interface ClientConfig {
/** 服务器地址 */
server: string;
/** 网络协议类型 */
protocolType?: NetProtocolType;
/** 是否使用 JSON 格式 (默认 true) */
json?: boolean;
/** 超时时间(ms) */
timeout?: number;
/** 其他配置 */
[key: string]: any;
}
/**
* 平台适配器
* 根据当前平台返回对应的 TSRPC 客户端实现
* 根据当前平台和协议类型返回对应的 TSRPC 客户端实现
*
* 注意: TSRPC 不同平台的库中 API 是重名的，所以使用别名导入
* 支持协议:
* - HTTP/HTTPS: 用于无状态的API调用
* - WebSocket: 用于实时双向通信
*
* 支持平台:
* - tsrpc-browser: 用于浏览器和 XMLHttpRequest 兼容的环境
* - tsrpc-miniapp: 用于微信、抖音、QQ 等小程序环境
*/
@@ -94,11 +103,12 @@ export class PlatformAdapter {
}
/**
* 创建对应平台的 TSRPC 客户端实例
* 创建对应平台和协议的 TSRPC 客户端实例
* @param config 客户端配置
*/
static createClient<T extends BaseServiceType>(config: ClientConfig): HttpClientBrowser<T> | HttpClientMiniapp<T> {
static createClient<T extends BaseServiceType>(config: ClientConfig): INetClient<T> {
const platform = this.detectPlatform();
const protocolType = config.protocolType || NetProtocolType.Http;
// 默认配置
const defaultConfig: ClientConfig = {
@@ -115,19 +125,50 @@ export class PlatformAdapter {
console.warn('[PlatformAdapter] Service protocol not set, please call setServiceProto() first');
}
console.log(`[PlatformAdapter] Creating ${protocolType} client for ${platform}:`, defaultConfig.server);
// 根据协议类型和平台创建对应的客户端
if (protocolType === NetProtocolType.WebSocket) {
return this.createWebSocketClient<T>(platform, defaultConfig);
} else {
return this.createHttpClient<T>(platform, defaultConfig);
}
}
/**
* 创建 HTTP 客户端
*/
private static createHttpClient<T extends BaseServiceType>(platform: PlatformType, config: ClientConfig): INetClient<T> {
let client: HttpClientBrowser<T> | HttpClientMiniapp<T>;
// 根据平台创建对应的客户端
if (platform === PlatformType.MiniApp) {
console.log('[PlatformAdapter] Creating MiniApp client:', defaultConfig.server);
client = new HttpClientMiniapp(this._serviceProto, defaultConfig) as HttpClientMiniapp<T>;
client = new HttpClientMiniapp(this._serviceProto, config) as HttpClientMiniapp<T>;
} else {
// 浏览器和其他 XMLHttpRequest 兼容环境使用 Browser 客户端
console.log('[PlatformAdapter] Creating Browser client:', defaultConfig.server);
client = new HttpClientBrowser(this._serviceProto, defaultConfig) as HttpClientBrowser<T>;
client = new HttpClientBrowser(this._serviceProto, config) as HttpClientBrowser<T>;
}
return client;
// 包装 HTTP 客户端使其符合 INetClient 接口
return {
callApi: async <Req, Res>(apiName: string, req: Req) => {
return await client.callApi(apiName, req);
}
} as INetClient<T>;
}
/**
* 创建 WebSocket 客户端
*/
private static createWebSocketClient<T extends BaseServiceType>(platform: PlatformType, config: ClientConfig): INetClient<T> {
let wsClient: WsClientBrowser<T> | WsClientMiniapp<T>;
if (platform === PlatformType.MiniApp) {
wsClient = new WsClientMiniapp(this._serviceProto, config) as WsClientMiniapp<T>;
} else {
wsClient = new WsClientBrowser(this._serviceProto, config) as WsClientBrowser<T>;
}
// 使用包装器统一接口
return new WebSocketClientWrapper<T>(wsClient);
}
/**

303
client/assets/scripts/Framework/Net/README.md
View File

@@ -1,303 +0,0 @@
# 网络通信模块 (Framework/Net)
## 📋 模块概述
基于 TSRPC 的网络通信层,支持多平台(浏览器、小程序),提供 API 调用和服务器消息监听功能。
## 🎯 核心特性
- ✅ 跨平台支持(浏览器/小程序)
- ✅ 自动平台检测和适配
- ✅ 服务协议动态配置
- ✅ API 调用和消息监听
- ✅ 自动重连机制
- ✅ 完整的事件系统
## 📦 依赖包
| 平台 | NPM 包 |
|------|--------|
| 浏览器 (Web) | `tsrpc-browser` |
| 小程序 (微信/抖音/QQ) | `tsrpc-miniapp` |
## 🗂️ 文件结构
```
Framework/Net/
├── NetManager.ts # 网络管理器(核心)
├── PlatformAdapter.ts # 平台适配器
├── NetConfig.ts # 网络配置
├── NetEvent.ts # 网络事件
├── LoginProtocol.ts # 登录协议(临时)
└── NetExample.ts # 使用示例
```
## 📘 核心类详解
### NetManager - 网络管理器
**职责**: 网络连接管理、消息收发、重连机制
**核心方法**:
```typescript
class NetManager {
// 获取单例
static getInstance(): NetManager;
// 设置服务协议(必须在 init 之前调用)
setServiceProto(serviceProto: ServiceProto): void;
// 初始化网络配置
init(config: NetConfig): void;
// 创建客户端实例并连接
connect(): Promise<boolean>;
// 断开连接并清理资源
disconnect(): void;
// 调用 API
callApi<Req, Res>(apiName: string, req: Req): Promise<Res | null>;
// 监听服务器消息
listenMsg<T>(msgName: string, handler: (msg: T) => void): void;
// 取消监听服务器消息
unlistenMsg(msgName: string, handler?: Function): void;
// 发送消息到服务器
sendMsg<T>(msgName: string, msg: T): Promise<void>;
// 监听网络事件
on(event: NetEvent, callback: Function): void;
// 取消监听网络事件
off(event: NetEvent, callback: Function): void;
}
```
### PlatformAdapter - 平台适配器
**职责**: 根据运行平台创建对应的 TSRPC 客户端
**技术实现**:
- 使用别名导入: `HttpClient as HttpClientBrowser` 和 `HttpClient as HttpClientMiniapp`
- 自动检测 Cocos 平台类型 (`sys.platform`)
- 根据平台实例化对应的客户端
**核心方法**:
```typescript
class PlatformAdapter {
// 设置服务协议
static setServiceProto(serviceProto: ServiceProto): void;
// 检测当前运行平台
static detectPlatform(): string;
// 创建对应平台的客户端实例
static createClient(config: NetConfig): HttpClient | null;
// 获取当前平台
static getCurrentPlatform(): string;
// 平台判断
static isMiniApp(): boolean;
static isBrowser(): boolean;
// 获取平台详细信息
static getPlatformInfo(): object;
}
```
### NetConfig - 网络配置
**配置接口**:
```typescript
interface NetConfig {
serverUrl: string; // 服务器地址
timeout?: number; // 超时时间(ms) 默认 30000
autoReconnect?: boolean; // 是否自动重连 默认 true
reconnectInterval?: number; // 重连间隔(ms) 默认 3000
maxReconnectTimes?: number; // 最大重连次数 默认 5
}
// 默认配置
const DefaultNetConfig: Partial<NetConfig>;
```
### NetEvent - 网络事件
**事件类型**:
```typescript
enum NetEvent {
Connected = "net_connected", // 连接成功
Disconnected = "net_disconnected", // 连接断开
Reconnecting = "net_reconnecting", // 正在重连
ReconnectSuccess = "net_reconnect_success", // 重连成功
ReconnectFailed = "net_reconnect_failed", // 重连失败
Error = "net_error", // 网络错误
Timeout = "net_timeout" // 连接超时
}
```
## 📝 使用指南
### 1. 基础使用流程
```typescript
import { NetManager } from './Framework/Net/NetManager';
import { NetConfig } from './Framework/Net/NetConfig';
import { NetEvent } from './Framework/Net/NetEvent';
import { serviceProto } from '../Shared/protocols/serviceProto';
// 1. 获取实例并设置协议
const netManager = NetManager.getInstance();
netManager.setServiceProto(serviceProto); // 必须在 init 之前
// 2. 监听网络事件
netManager.on(NetEvent.Connected, () => {
console.log('✅ 网络已连接');
});
netManager.on(NetEvent.Disconnected, () => {
console.log('❌ 网络已断开');
});
netManager.on(NetEvent.Error, (error: any) => {
console.error('⚠️ 网络错误:', error);
});
// 3. 初始化配置
const config: NetConfig = {
serverUrl: 'http://localhost:3000',
timeout: 30000,
autoReconnect: true,
reconnectInterval: 3000,
maxReconnectTimes: 5
};
netManager.init(config);
// 4. 连接服务器
const success = await netManager.connect();
if (success) {
console.log('✅ 网络初始化成功');
}
```
### 2. 调用 API
```typescript
import { ReqLogin, ResLogin } from '../Shared/protocols/PtlLogin';
// 调用登录 API
const result = await netManager.callApi<ReqLogin, ResLogin>('Login', {
username: 'testUser',
password: '123456'
});
if (result) {
console.log('登录成功:', result);
}
```
### 3. 监听服务器消息
```typescript
import { MsgUserJoin } from '../Shared/protocols/MsgUserJoin';
// 监听用户加入消息
netManager.listenMsg<MsgUserJoin>('UserJoin', (msg) => {
console.log('有新用户加入:', msg);
});
// 取消监听
netManager.unlistenMsg('UserJoin');
```
### 4. 发送消息到服务器
```typescript
import { MsgChat } from '../Shared/protocols/MsgChat';
// 发送聊天消息
await netManager.sendMsg<MsgChat>('Chat', {
content: 'Hello World!'
});
```
## 🔄 协议同步
### 同步脚本配置
**文件**: 项目根目录的 `sync-shared.js`
```javascript
// 服务端共享目录
const serverSharedDir = path.join(__dirname, '../server/src/shared');
// 客户端目标目录
const clientSharedDir = path.join(__dirname, 'assets/scripts/Shared');
```
### 使用步骤
1. **确保服务端项目位置**: 服务端项目应该在 `../server` 目录
2. **运行同步命令**:
```bash
npm run sync-shared
```
3. **导入协议**:
```typescript
import { serviceProto } from '../Shared/protocols/serviceProto';
import { ReqLogin, ResLogin } from '../Shared/protocols/PtlLogin';
```
## ⚠️ 注意事项
1. **协议必须先设置**: 在调用 `init()` 之前,必须先调用 `setServiceProto()`
2. **连接状态检查**: 调用 API 前确保已连接,否则会返回 null
3. **错误处理**: 建议监听 `NetEvent.Error` 事件处理网络错误
4. **资源清理**: 应用退出时调用 `disconnect()` 清理资源
5. **平台兼容**: PlatformAdapter 会自动处理平台差异,无需手动判断
## 🔍 调试技巧
### 启用详细日志
```typescript
// NetManager 内部已有详细的 console.log
// 可以根据日志前缀过滤:
// [NetManager] - 网络管理器日志
// [PlatformAdapter] - 平台适配器日志
```
### 常见问题
**问题1**: `协议未设置` 错误
```typescript
// 解决: 确保在 init 之前调用 setServiceProto
netManager.setServiceProto(serviceProto);
netManager.init(config);
```
**问题2**: `API 调用返回 null`
```typescript
// 解决: 检查网络连接状态
netManager.on(NetEvent.Connected, async () => {
// 在连接成功后再调用 API
const result = await netManager.callApi('Login', data);
});
```
**问题3**: 小程序平台客户端创建失败
```typescript
// 解决: 确保已安装 tsrpc-miniapp
npm install tsrpc-miniapp
```
## 📚 参考资料
- [TSRPC 官方文档](https://tsrpc.cn/)
- [Cocos Creator 官方文档](https://docs.cocos.com/creator/manual/zh/)

11
client/assets/scripts/Framework/Net/README.md.meta
View File

@@ -1,11 +0,0 @@
{
"ver": "1.0.1",
"importer": "text",
"imported": true,
"uuid": "6eb67b95-26c3-410a-a9ee-441d4fa23371",
"files": [
".json"
],
"subMetas": {},
"userData": {}
}