drgame-cc 1.0.52 → 1.0.55

package/drscript/virtualgamepad/VirtualGamepad.ts

@@ -0,0 +1,638 @@
+// ========================================================================
+// VirtualGamepad — WebSocket 客户端 + 手柄输入管理器
+// ========================================================================
+
+// ==================== 配置常量 ====================
+
+export const VIRTUAL_GAMEPAD_GAME_ID = "rexueqiangshou";
+export const VIRTUAL_GAMEPAD_PLAYER_ID = "player1";
+export const VIRTUAL_GAMEPAD_DEVELOPMENT_WS_URL = "ws://10.40.92.42:3000";
+export const VIRTUAL_GAMEPAD_PRODUCTION_WS_URL = "wss://hyp.huyingpai.com/huyingpai/lewo/ws";
+export const VIRTUAL_GAMEPAD_H5_URL = "https://docp.daoran.tv/vconsole/index.html";
+export const VIRTUAL_GAMEPAD_DEVELOPMENT_WXACODE_URL = "https://hyp.huyingpai.com/API_USER_CS/wxacode/unlimited";
+export const VIRTUAL_GAMEPAD_PRODUCTION_WXACODE_URL = "https://hyp.huyingpai.com/API_USER/wxacode/unlimited";
+export const VIRTUAL_GAMEPAD_WXACODE_PAGE = "pages/gamepad/gamepad";
+export const VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE = "lewo";
+export const VIRTUAL_GAMEPAD_MAX_MEMBERS = 2;
+export const VIRTUAL_GAMEPAD_STOP_TIMEOUT_MS = 500;
+
+export type VirtualGamepadEnvironment = "development" | "production";
+export const VIRTUAL_GAMEPAD_DEFAULT_ENVIRONMENT: VirtualGamepadEnvironment = "production";
+export type VirtualGamepadQrMode = "h5" | "json";
+export const VIRTUAL_GAMEPAD_QR_MODE: VirtualGamepadQrMode = "h5";
+
+declare const global: any;
+
+function getRuntimeValue(key: string): string {
+    let runtimeRoot: any = typeof window != "undefined" ? window : (typeof global != "undefined" ? global : null);
+    if (runtimeRoot && runtimeRoot[key]) return String(runtimeRoot[key]);
+    try {
+        if (cc && cc.sys && cc.sys.localStorage) {
+            return cc.sys.localStorage.getItem(key) || "";
+        }
+    } catch (e) { /* ignore */ }
+    return "";
+}
+
+function getWsUrl(): string {
+    return getRuntimeValue("RXQS_GAMEPAD_WS_URL") ||
+        (getEnvironment() == "production" ? VIRTUAL_GAMEPAD_PRODUCTION_WS_URL : VIRTUAL_GAMEPAD_DEVELOPMENT_WS_URL);
+}
+function getWxacodeUrl(): string {
+    return getRuntimeValue("RXQS_GAMEPAD_WXACODE_URL") ||
+        (getEnvironment() == "production" ? VIRTUAL_GAMEPAD_PRODUCTION_WXACODE_URL : VIRTUAL_GAMEPAD_DEVELOPMENT_WXACODE_URL);
+}
+function getEnvironment(): VirtualGamepadEnvironment {
+    let env = getRuntimeValue("RXQS_GAMEPAD_ENVIRONMENT");
+    if (env == "development" || env == "production") return env;
+    return VIRTUAL_GAMEPAD_DEFAULT_ENVIRONMENT;
+}
+function getH5Url(): string { return getRuntimeValue("RXQS_GAMEPAD_H5_URL") || VIRTUAL_GAMEPAD_H5_URL; }
+function getRoomId(): string { return getRuntimeValue("RXQS_GAMEPAD_ROOM_ID"); }
+function getToken(): string { return getRuntimeValue("RXQS_GAMEPAD_TOKEN"); }
+function getQrMode(): VirtualGamepadQrMode {
+    let mode = getRuntimeValue("RXQS_GAMEPAD_QR_MODE");
+    return mode == "json" ? "json" : VIRTUAL_GAMEPAD_QR_MODE;
+}
+
+// ==================== Client ====================
+
+export type VirtualGamepadConnectionState = "idle" | "connecting" | "open" | "joined" | "closed" | "error";
+
+interface ClientOptions {
+    wsUrl: string;
+    roomId: string;
+    deviceId: string;
+    game: string;
+    userId: string;
+    userType: "xiaomi" | "guest";
+    guestId?: string;
+    token?: string;
+    maxMembers: number;
+}
+
+class Client {
+    private socket: WebSocket | null = null;
+    private options: ClientOptions | null = null;
+    private manualClose: boolean = false;
+    private reconnectCount: number = 0;
+    private heartbeatTimer: any = -1;
+    private reconnectTimer: any = -1;
+    private readonly maxReconnectCount: number = 3;
+    private readonly heartbeatMs: number = 10000;
+
+    public onStateChange: ((state: VirtualGamepadConnectionState, reason?: string) => void) | null = null;
+    public onMessage: ((message: any) => void) | null = null;
+
+    public connect(options: ClientOptions) {
+        this.options = options;
+        this.manualClose = false;
+        this.clearReconnect();
+        this.openSocket();
+    }
+
+    public close() {
+        this.manualClose = true;
+        this.clearHeartbeat();
+        this.clearReconnect();
+        if (this.socket) {
+            this.socket.onopen = null;
+            this.socket.onmessage = null;
+            this.socket.onclose = null;
+            this.socket.onerror = null;
+            try { this.socket.close(); } catch (e) { /* ignore */ }
+        }
+        this.socket = null;
+        this.emitState("closed");
+    }
+
+    public send(message: any): boolean {
+        if (!this.socket || this.socket.readyState != WebSocket.OPEN) return false;
+        try { this.socket.send(JSON.stringify(message)); return true; } catch (e) { return false; }
+    }
+
+    private openSocket() {
+        if (!this.options || !this.options.wsUrl) return;
+        this.clearHeartbeat();
+        this.emitState("connecting");
+        let opts = this.options;
+        let query: Record<string, string> = {
+            roomId: opts.roomId, deviceId: opts.deviceId, role: "game",
+            userId: opts.userId, userType: opts.userType, maxMembers: String(opts.maxMembers)
+        };
+        if (opts.guestId) query.guestId = opts.guestId;
+        if (opts.token) query.token = opts.token;
+        let url = this.appendParams(opts.wsUrl, query);
+        try {
+            this.socket = new WebSocket(url);
+            this.socket.onopen = this.handleOpen.bind(this);
+            this.socket.onmessage = this.handleMessage.bind(this);
+            this.socket.onclose = this.handleClose.bind(this);
+            this.socket.onerror = this.handleError.bind(this);
+        } catch (e) {
+            this.handleError(e);
+        }
+    }
+
+    private handleOpen() {
+        if (!this.options) return;
+        this.reconnectCount = 0;
+        this.emitState("open");
+        let msg: any = {
+            type: "join", roomId: this.options.roomId, role: "game",
+            deviceId: this.options.deviceId, userId: this.options.userId,
+            userType: this.options.userType, maxMembers: this.options.maxMembers, game: this.options.game
+        };
+        if (this.options.guestId) msg.guestId = this.options.guestId;
+        if (this.options.token) msg.token = this.options.token;
+        console.log("[VirtualGamepad][WSS][Send] join", { type: msg.type, roomId: msg.roomId, role: msg.role, deviceId: msg.deviceId, userId: msg.userId, userType: msg.userType, guestId: msg.guestId || "", maxMembers: msg.maxMembers, game: msg.game, hasToken: !!msg.token });
+        this.send(msg);
+        this.startHeartbeat();
+    }
+
+    private handleMessage(event: MessageEvent) {
+        let data = event && event.data;
+        let message: any = null;
+        try { message = typeof data == "string" ? JSON.parse(data) : data; } catch (e) { return; }
+        if (!message) return;
+        if (message.type != "pong") console.log("[VirtualGamepad][WSS][Receive]", message);
+        if (message.type == "joined" || message.type == "welcome") this.emitState("joined");
+        if (this.onMessage) this.onMessage(message);
+    }
+
+    private handleClose(event?: any) {
+        this.clearHeartbeat();
+        this.socket = null;
+        this.emitState("closed", event && event.reason);
+        if (!this.manualClose) this.scheduleReconnect();
+    }
+
+    private handleError(event?: any) {
+        this.emitState("error", event && event.message);
+        if (!this.manualClose && (!this.socket || this.socket.readyState == WebSocket.CLOSED)) this.scheduleReconnect();
+    }
+
+    private startHeartbeat() {
+        this.clearHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.options) return;
+            this.send({ type: "ping", roomId: this.options.roomId, deviceId: this.options.deviceId, role: "game", timestamp: Date.now(), ts: Date.now() });
+        }, this.heartbeatMs);
+    }
+
+    private scheduleReconnect() {
+        if (this.reconnectCount >= this.maxReconnectCount) return;
+        this.clearReconnect();
+        this.reconnectCount++;
+        this.reconnectTimer = setTimeout(() => this.openSocket(), 1200 * this.reconnectCount);
+    }
+
+    private appendParams(url: string, params: Record<string, string>): string {
+        let q = Object.keys(params).map(k => encodeURIComponent(k) + "=" + encodeURIComponent(params[k] || "")).join("&");
+        return url + (url.indexOf("?") >= 0 ? "&" : "?") + q;
+    }
+
+    private emitState(state: VirtualGamepadConnectionState, reason?: string) {
+        if (this.onStateChange) this.onStateChange(state, reason);
+    }
+
+    private clearHeartbeat() {
+        if (this.heartbeatTimer != -1) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = -1; }
+    }
+    private clearReconnect() {
+        if (this.reconnectTimer != -1) { clearTimeout(this.reconnectTimer); this.reconnectTimer = -1; }
+    }
+}
+
+// ==================== Manager ====================
+
+export type VirtualGamepadGameState = "ready" | "playing" | "paused" | "ended";
+export type VirtualGamepadUserType = "xiaomi" | "guest";
+export type VirtualGamepadSunCodeState = "idle" | "loading" | "ready" | "error";
+
+export interface VirtualGamepadIdentity {
+    userId: string;
+    userType: VirtualGamepadUserType;
+    guestId?: string;
+}
+
+export interface VirtualGamepadMoveInput {
+    x: number;
+    y: number;
+    seq?: number;
+    ts?: number;
+    raw?: any;
+    holdMode?: boolean;
+    stopTimeoutMs?: number;
+    side?: string;
+    direction?: string;
+    action?: string;
+}
+
+export type VirtualGamepadControlType = "stick" | "button" | "shoulder" | "trigger" | "back";
+
+export interface VirtualGamepadControlInput {
+    type: VirtualGamepadControlType;
+    action: string;
+    pressed: boolean;
+    side?: string;
+    key?: string;
+    direction?: string;
+    x?: number;
+    y?: number;
+    playerId?: string;
+    seq?: number;
+    ts?: number;
+    raw?: any;
+}
+
+export interface VirtualGamepadStatus {
+    connectionState: VirtualGamepadConnectionState;
+    controllerConnected: boolean;
+    roomId: string;
+    deviceId: string;
+    userId: string;
+    userType: VirtualGamepadUserType;
+    identityText: string;
+    hasToken: boolean;
+    maxMembers: number;
+    sunCodeState: VirtualGamepadSunCodeState;
+    sunCodeDataUrl: string;
+    sunCodeError?: string;
+    h5Url: string;
+    qrPayload: string;
+    statusText: string;
+    lastError?: string;
+}
+
+type MoveListener = (input: VirtualGamepadMoveInput) => void;
+type StatusListener = (status: VirtualGamepadStatus) => void;
+type ControlListener = (input: VirtualGamepadControlInput) => void;
+
+interface ListenerMap {
+    move: MoveListener;
+    status: StatusListener;
+    button: ControlListener;
+    shoulder: ControlListener;
+    trigger: ControlListener;
+    back: ControlListener;
+}
+
+export default class VirtualGamepadManager {
+    private static _instance: VirtualGamepadManager | null = null;
+
+    public static getInstance(): VirtualGamepadManager {
+        if (!VirtualGamepadManager._instance) VirtualGamepadManager._instance = new VirtualGamepadManager();
+        return VirtualGamepadManager._instance;
+    }
+
+    private client: Client | null = null;
+    private roomId: string = "";
+    private deviceId: string = "";
+    private identity: VirtualGamepadIdentity = { userId: "", userType: "guest" };
+    private started: boolean = false;
+    private connectionState: VirtualGamepadConnectionState = "idle";
+    private controllerConnected: boolean = false;
+    private lastError: string = "";
+    private lastInputSeq: number = -1;
+    private gameState: VirtualGamepadGameState = "ready";
+    private sunCodeState: VirtualGamepadSunCodeState = "idle";
+    private sunCodeDataUrl: string = "";
+    private sunCodeError: string = "";
+    private sunCodeRequestSerial: number = 0;
+    private _listeners = new Map<string, Function[]>();
+
+    private constructor() {
+        this.deviceId = this.getOrCreateDeviceId();
+        this.identity = this.resolveIdentity();
+        this.roomId = getRoomId() || this.identity.userId || this.createRoomId();
+    }
+
+    public start() {
+        if (this.started) { this.emit("status", this.getStatus()); return; }
+        this.started = true;
+        this.controllerConnected = false;
+        this.lastInputSeq = -1;
+        this.lastError = "";
+        this.identity = this.resolveIdentity();
+        let configuredRoomId = getRoomId();
+        this.roomId = configuredRoomId || this.identity.userId || this.createRoomId();
+        if (configuredRoomId) console.warn("[VirtualGamepad][Identity] roomId uses runtime override", { roomId: configuredRoomId, configKey: "RXQS_GAMEPAD_ROOM_ID" });
+        let token = getToken();
+        this.client = new Client();
+        this.client.onStateChange = this.handleClientState.bind(this);
+        this.client.onMessage = this.handleMessage.bind(this);
+        this.client.connect({
+            wsUrl: getWsUrl(), roomId: this.roomId, deviceId: this.deviceId,
+            game: VIRTUAL_GAMEPAD_GAME_ID, userId: this.identity.userId,
+            userType: this.identity.userType, guestId: this.identity.guestId,
+            token: token, maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS
+        });
+        console.log("[VirtualGamepad][Identity] connect", { environment: getEnvironment(), userType: this.identity.userType, userId: this.maskUserId(this.identity.userId), roomId: this.roomId, hasToken: !!token, maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS });
+        this.requestSunCode();
+        this.emit("status", this.getStatus());
+    }
+
+    public stop() {
+        this.started = false;
+        this.controllerConnected = false;
+        this.lastInputSeq = -1;
+        this.sunCodeRequestSerial++;
+        if (this.client) { this.client.close(); this.client = null; }
+        this.connectionState = "closed";
+        this.emit("status", this.getStatus());
+    }
+
+    public setGameState(state: VirtualGamepadGameState) { this.gameState = state; }
+
+    public getStatus(): VirtualGamepadStatus {
+        return {
+            connectionState: this.connectionState,
+            controllerConnected: this.controllerConnected,
+            roomId: this.roomId,
+            deviceId: this.deviceId,
+            userId: this.identity.userId,
+            userType: this.identity.userType,
+            identityText: this.getIdentityText(),
+            hasToken: !!getToken(),
+            maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS,
+            sunCodeState: this.sunCodeState,
+            sunCodeDataUrl: this.sunCodeDataUrl,
+            sunCodeError: this.sunCodeError,
+            h5Url: this.getH5Url(),
+            qrPayload: this.getQrPayload(),
+            statusText: this.getStatusText(),
+            lastError: this.lastError
+        };
+    }
+
+    public getQrPayload(): string {
+        if (getQrMode() == "json") {
+            return JSON.stringify({ wsUrl: getWsUrl(), roomId: this.roomId, maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS, token: getToken() });
+        }
+        return this.getH5Url();
+    }
+
+    public getH5Url(): string {
+        return this.appendParams(getH5Url(), {
+            game: VIRTUAL_GAMEPAD_GAME_ID, roomId: this.roomId, wsUrl: getWsUrl(),
+            playerId: VIRTUAL_GAMEPAD_PLAYER_ID, maxMembers: String(VIRTUAL_GAMEPAD_MAX_MEMBERS), token: getToken()
+        });
+    }
+
+    public on<K extends keyof ListenerMap>(type: K, listener: ListenerMap[K]) {
+        if (!listener) return;
+        let list = this._listeners.get(type);
+        if (!list) { list = []; this._listeners.set(type, list); }
+        if (list.indexOf(listener) < 0) list.push(listener);
+    }
+    public off<K extends keyof ListenerMap>(type: K, listener: ListenerMap[K]) {
+        let list = this._listeners.get(type);
+        if (!list) return;
+        let i = list.indexOf(listener);
+        if (i >= 0) list.splice(i, 1);
+    }
+
+    private handleClientState(state: VirtualGamepadConnectionState, reason?: string) {
+        this.connectionState = state;
+        if (state == "error") this.lastError = reason || "连接失败";
+        if (state == "closed" || state == "error") { this.controllerConnected = false; this.emit("move", { x: 0, y: 0 }); }
+        this.emit("status", this.getStatus());
+    }
+
+    private handleMessage(message: any) {
+        if (!this.isCurrentRoomMessage(message)) {
+            console.warn("[VirtualGamepad][WSS] ignored message from another room", { expectedRoomId: this.roomId, receivedRoomId: message && message.roomId, type: message && message.type });
+            return;
+        }
+        if (message.type == "error") { this.lastError = message.message || message.error || "手柄服务返回错误"; this.connectionState = "error"; this.emit("status", this.getStatus()); return; }
+        if (message.type == "pong") return;
+        if (message.type == "room_state") { this.handleRoomState(message); return; }
+        if (this.isControllerJoinMessage(message)) { console.log("[VirtualGamepad][WSS][Presence] controller joined", message); this.setControllerConnected(true); return; }
+        if (this.isControllerLeaveMessage(message)) { console.log("[VirtualGamepad][WSS][Presence] controller left", message); this.setControllerConnected(false); this.emit("move", { x: 0, y: 0, raw: message }); return; }
+        if (message.type == "input" || message.action) this.handleInput(message);
+    }
+
+    private handleInput(message: any) {
+        let payload = message.input || message;
+        let playerId = this.getMessagePlayerId(message) || this.getMessagePlayerId(payload);
+        if (playerId && playerId != VIRTUAL_GAMEPAD_PLAYER_ID) return;
+        let seq = typeof payload.seq == "number" ? payload.seq : message.seq;
+        if (typeof seq == "number") { if (seq <= this.lastInputSeq) return; this.lastInputSeq = seq; }
+        this.setControllerConnected(true);
+
+        // 按 input.type 分发
+        if (payload && this.dispatchControl(message, payload)) return;
+
+        // 旧格式兼容：move / stop
+        if (payload.action == "move" || payload.action == "stop") {
+            this.emit("move", {
+                x: this.clampAxis(payload.action == "stop" ? 0 : Number(payload.x) || 0),
+                y: this.clampAxis(payload.action == "stop" ? 0 : Number(payload.y) || 0),
+                seq, ts: this.getMessageTimestamp(payload) || this.getMessageTimestamp(message), raw: message
+            });
+        }
+    }
+
+    /** 按 input.type 分发到对应事件，返回 true 表示已处理 */
+    private dispatchControl(message: any, input: any): boolean {
+        if (!input || !input.type) return false;
+        let t = String(input.type).toLowerCase();
+        let key = this.normalizeKey(input.key);
+        let pressed = input.pressed !== false && input.action != "release" && input.action != "up" && input.action != "stop";
+        let action = (input && input.action ? String(input.action).toLowerCase() : "press");
+
+        // 摇杆
+        if (t == "joystick" || t == "joystick_stick") {
+            let side = this.normalizeKey(input.side || "left");
+            this.emit("move", {
+                x: pressed ? this.clampAxis(Number(input.x) || 0) : 0,
+                y: pressed ? this.clampAxis(Number(input.y) || 0) : 0,
+                seq: input.seq || message.seq, ts: this.getMessageTimestamp(input) || this.getMessageTimestamp(message),
+                raw: message, holdMode: true, side, direction: input.direction || "", action
+            });
+            return true;
+        }
+
+        // 按键
+        if (t == "button") {
+            let et = (key == "back") ? "back" as const : "button" as const;
+            this.emit(et, this.buildInput(message, { type: et, action, pressed, key }));
+            return true;
+        }
+
+        // 肩键 / 返回 / 扳机
+        if (t == "shoulder" || t == "back" || t == "trigger") {
+            this.emit(t as any, this.buildInput(message, { type: t as any, action, pressed, key }));
+            return true;
+        }
+
+        return false;
+    }
+
+    private buildInput(message: any, data: any): VirtualGamepadControlInput {
+        let rawInput = message && message.input ? message.input : message;
+        return {
+            type: data.type, action: data.action, pressed: data.pressed,
+            side: data.side, key: data.key, direction: data.direction,
+            x: typeof data.x == "number" ? data.x : undefined,
+            y: typeof data.y == "number" ? data.y : undefined,
+            playerId: this.getMessagePlayerId(message) || this.getMessagePlayerId(rawInput) || VIRTUAL_GAMEPAD_PLAYER_ID,
+            seq: rawInput && typeof rawInput.seq == "number" ? rawInput.seq : message.seq,
+            ts: this.getMessageTimestamp(rawInput) || this.getMessageTimestamp(message),
+            raw: message
+        };
+    }
+
+    private normalizeKey(key: any): string { return String(key || "").toLowerCase(); }
+    private isCurrentRoomMessage(message: any): boolean { return !message || !message.roomId || message.roomId == this.roomId; }
+
+    private isControllerJoinMessage(message: any): boolean {
+        if (!message || message.role == "game") return false;
+        if (message.type == "device_join") return this.isTargetPlayerMessage(message);
+        if (message.role == "controller" && (message.type == "join" || message.type == "joined")) return true;
+        return ["peer_joined", "player_joined", "controller_joined", "controller_connected"].indexOf(message.type) >= 0;
+    }
+
+    private isControllerLeaveMessage(message: any): boolean {
+        if (!message) return false;
+        if (message.type == "device_leave") return this.isTargetPlayerMessage(message);
+        return ["peer_left", "player_left", "controller_left", "controller_disconnected", "leave"].indexOf(message.type) >= 0;
+    }
+
+    private handleRoomState(message: any) {
+        let items = message.slots || message.devices;
+        if (items && items.length) { this.setControllerConnected(this.hasPlayerOneInList(items)); return; }
+        if (typeof message.playerCount == "number") { this.setControllerConnected(message.playerCount > 0); return; }
+        if (message.players && message.players[VIRTUAL_GAMEPAD_PLAYER_ID]) { this.setControllerConnected(true); return; }
+        if (message.devices && message.devices[VIRTUAL_GAMEPAD_PLAYER_ID]) this.setControllerConnected(true);
+    }
+
+    private isTargetPlayerMessage(message: any): boolean { let pid = this.getMessagePlayerId(message); return !pid || pid == VIRTUAL_GAMEPAD_PLAYER_ID; }
+
+    private getMessagePlayerId(message: any): string {
+        if (!message) return "";
+        if (message.playerId) return String(message.playerId);
+        if (message.from == "player1" || message.from == "player2") return String(message.from);
+        if (message.role == "player1" || message.role == "player2") return String(message.role);
+        return "";
+    }
+
+    private hasPlayerOneInList(list: any): boolean {
+        if (!list || !list.length) return false;
+        return list.some((item: any) => item && item.role == VIRTUAL_GAMEPAD_PLAYER_ID && item.occupied !== false);
+    }
+
+    private getMessageTimestamp(message: any): number { return typeof message.ts == "number" ? message.ts : typeof message.timestamp == "number" ? message.timestamp : 0; }
+    private setControllerConnected(connected: boolean) {
+        if (this.controllerConnected == connected) return;
+        this.controllerConnected = connected;
+        if (!connected) this.emit("move", { x: 0, y: 0 });
+        this.emit("status", this.getStatus());
+    }
+
+    private emit(type: string, ...args: any[]) {
+        let list = this._listeners.get(type);
+        if (list) { for (let i = list.length - 1; i >= 0; i--) list[i](...args); }
+    }
+
+    private getStatusText(): string {
+        if (this.controllerConnected) return "虚拟手柄已连接";
+        if (this.connectionState == "connecting") return "正在连接手柄服务";
+        if (this.connectionState == "open" || this.connectionState == "joined") return "等待手柄扫码连接";
+        if (this.connectionState == "error") return this.lastError || "手柄服务连接失败";
+        return "虚拟手柄未连接";
+    }
+
+    private appendParams(url: string, params: Record<string, string>): string {
+        let q = Object.keys(params).map(k => encodeURIComponent(k) + "=" + encodeURIComponent(params[k] || "")).join("&");
+        let hi = url.indexOf("#");
+        if (hi >= 0) { let p = url.substring(0, hi), h = url.substring(hi + 1); return p + "#" + h + (h.indexOf("?") >= 0 ? "&" : "?") + q; }
+        return url + (url.indexOf("?") >= 0 ? "&" : "?") + q;
+    }
+    private clampAxis(v: number): number { return v > 1 ? 1 : v < -1 ? -1 : v; }
+
+    private getOrCreateDeviceId(): string {
+        let key = "rxqs_virtual_gamepad_device_id";
+        try {
+            let ls = cc.sys && cc.sys.localStorage;
+            if (ls) { let s = ls.getItem(key); if (s) return s; let c = this.createId("game"); ls.setItem(key, c); return c; }
+        } catch (e) { /* ignore */ }
+        return this.createId("game");
+    }
+
+    private requestSunCode() {
+        let serial = ++this.sunCodeRequestSerial;
+        this.sunCodeState = "loading";
+        this.sunCodeDataUrl = "";
+        this.sunCodeError = "";
+        this.emit("status", this.getStatus());
+        let xhr = new XMLHttpRequest();
+        xhr.timeout = 10000;
+        let url = getWxacodeUrl();
+        xhr.open("POST", url, true);
+        xhr.responseType = "arraybuffer";
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.onload = () => {
+            if (serial != this.sunCodeRequestSerial || !this.started) return;
+            if (xhr.status < 200 || xhr.status >= 300 || !xhr.response) { this.failSunCode("太阳码接口返回 " + xhr.status, serial); return; }
+            let bytes = new Uint8Array(xhr.response as ArrayBuffer);
+            let mime = this.detectImageMimeType(bytes);
+            if (!mime) { this.failSunCode("太阳码接口未返回有效图片", serial); return; }
+            this.sunCodeDataUrl = "data:" + mime + ";base64," + this.encodeBase64(bytes);
+            this.sunCodeState = "ready";
+            this.sunCodeError = "";
+            console.log("[VirtualGamepad][SunCode] ready", { environment: getEnvironment(), url, roomId: this.roomId, page: VIRTUAL_GAMEPAD_WXACODE_PAGE, projectCode: VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE, byteLength: bytes.length, mimeType: mime });
+            this.emit("status", this.getStatus());
+        };
+        xhr.onerror = () => this.failSunCode("太阳码接口网络错误", serial);
+        xhr.ontimeout = () => this.failSunCode("太阳码接口请求超时", serial);
+        xhr.send(JSON.stringify({ scene: this.roomId, page: VIRTUAL_GAMEPAD_WXACODE_PAGE, projectCode: VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE }));
+    }
+
+    private failSunCode(msg: string, serial: number) {
+        if (serial != this.sunCodeRequestSerial || !this.started) return;
+        this.sunCodeState = "error";
+        this.sunCodeDataUrl = "";
+        this.sunCodeError = msg;
+        console.warn("[VirtualGamepad][SunCode] unavailable", { roomId: this.roomId, message: msg });
+        this.emit("status", this.getStatus());
+    }
+
+    private detectImageMimeType(bytes: Uint8Array): string {
+        if (bytes.length >= 3 && bytes[0] == 0xff && bytes[1] == 0xd8 && bytes[2] == 0xff) return "image/jpeg";
+        if (bytes.length >= 8 && bytes[0] == 0x89 && bytes[1] == 0x50 && bytes[2] == 0x4e && bytes[3] == 0x47) return "image/png";
+        return "";
+    }
+
+    private encodeBase64(bytes: Uint8Array): string {
+        let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        let out = "";
+        for (let i = 0; i < bytes.length; i += 3) {
+            let a = bytes[i], b = i + 1 < bytes.length ? bytes[i + 1] : 0, c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+            out += chars.charAt(a >> 2) + chars.charAt(((a & 3) << 4) | (b >> 4));
+            out += i + 1 < bytes.length ? chars.charAt(((b & 15) << 2) | (c >> 6)) : "=";
+            out += i + 2 < bytes.length ? chars.charAt(c & 63) : "=";
+        }
+        return out;
+    }
+
+    private resolveIdentity(): VirtualGamepadIdentity {
+        let guestId = this.getOrCreateGuestId();
+        return { userId: guestId, userType: "guest", guestId };
+    }
+
+    private getOrCreateGuestId(): string {
+        let key = "rxqs_virtual_gamepad_guest_id";
+        try {
+            let ls = cc.sys && cc.sys.localStorage;
+            if (ls) { let s = ls.getItem(key); if (s) return s; let c = this.createId("guest"); ls.setItem(key, c); return c; }
+        } catch (e) { /* ignore */ }
+        return this.createId("guest");
+    }
+
+    private getIdentityText(): string { let l = this.identity.userType == "xiaomi" ? "小米用户" : "游客"; return l + " " + this.maskUserId(this.identity.userId); }
+    private maskUserId(id: string): string { let v = String(id || ""); return v.length <= 8 ? v : v.substring(0, 4) + "..." + v.substring(v.length - 4); }
+    private createRoomId(): string { return this.createId("rxqs"); }
+    private createId(prefix: string): string { return prefix + "_" + Date.now().toString(36) + "_" + Math.floor(Math.random() * 100000).toString(36); }
+}