drgame-cc 1.0.16 → 1.0.18

package/drscript/virtualgamepad/VirtualGamepadManager.ts

@@ -0,0 +1,809 @@
+import VirtualGamepadClient, { VirtualGamepadConnectionState } from "./VirtualGamepadClient";
+import VirtualGamepadConfig, {
+    VIRTUAL_GAMEPAD_GAME_ID,
+    VIRTUAL_GAMEPAD_MAX_MEMBERS,
+    VIRTUAL_GAMEPAD_PLAYER_ID,
+    VIRTUAL_GAMEPAD_WXACODE_PAGE,
+    VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE
+} from "./VirtualGamepadConfig";
+// import { GameVoManager } from "../manager/GameVoManager";
+
+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" | "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 ConfirmListener = (pressed: boolean, raw?: any) => void;
+type StatusListener = (status: VirtualGamepadStatus) => void;
+type ControlListener = (input: VirtualGamepadControlInput) => void;
+
+export default class VirtualGamepadManager {
+    private static instance: VirtualGamepadManager | null = null;
+
+    public static getInstance(): VirtualGamepadManager {
+        let instance = this.instance;
+        if (!instance) {
+            instance = new VirtualGamepadManager();
+            this.instance = instance;
+        }
+        return instance;
+    }
+
+    private client: VirtualGamepadClient | 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 moveListeners: MoveListener[] = [];
+    private confirmListeners: ConfirmListener[] = [];
+    private statusListeners: StatusListener[] = [];
+    private controlListeners: ControlListener[] = [];
+    private stickListeners: ControlListener[] = [];
+    private buttonListeners: ControlListener[] = [];
+    private shoulderListeners: ControlListener[] = [];
+    private backListeners: ControlListener[] = [];
+
+    private constructor() {
+        this.deviceId = this.getOrCreateDeviceId();
+        this.identity = this.resolveIdentity();
+        this.roomId = VirtualGamepadConfig.getRoomId() || this.identity.userId || this.createRoomId();
+    }
+
+    public start() {
+        if (this.started) {
+            this.emitStatus();
+            return;
+        }
+        this.started = true;
+        this.controllerConnected = false;
+        this.lastInputSeq = -1;
+        this.lastError = "";
+        this.identity = this.resolveIdentity();
+        let configuredRoomId = VirtualGamepadConfig.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 = VirtualGamepadConfig.getToken();
+        this.client = new VirtualGamepadClient();
+        this.client.onStateChange = this.handleClientState.bind(this);
+        this.client.onMessage = this.handleMessage.bind(this);
+        this.client.connect({
+            wsUrl: VirtualGamepadConfig.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: VirtualGamepadConfig.getEnvironment(),
+            userType: this.identity.userType,
+            userId: this.maskUserId(this.identity.userId),
+            roomId: this.roomId,
+            hasToken: !!token,
+            maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS
+        });
+        this.requestSunCode();
+        this.emitStatus();
+    }
+
+    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.emitStatus();
+    }
+
+    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: !!VirtualGamepadConfig.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 (VirtualGamepadConfig.getQrMode() == "json") {
+            return JSON.stringify({
+                wsUrl: VirtualGamepadConfig.getWsUrl(),
+                roomId: this.roomId,
+                maxMembers: VIRTUAL_GAMEPAD_MAX_MEMBERS,
+                token: VirtualGamepadConfig.getToken()
+            });
+        }
+        return this.getH5Url();
+    }
+
+    public getH5Url(): string {
+        return this.appendParams(VirtualGamepadConfig.getH5Url(), {
+            game: VIRTUAL_GAMEPAD_GAME_ID,
+            roomId: this.roomId,
+            wsUrl: VirtualGamepadConfig.getWsUrl(),
+            playerId: VIRTUAL_GAMEPAD_PLAYER_ID,
+            maxMembers: String(VIRTUAL_GAMEPAD_MAX_MEMBERS),
+            token: VirtualGamepadConfig.getToken()
+        });
+    }
+
+    public onMove(listener: MoveListener) {
+        if (listener && this.moveListeners.indexOf(listener) < 0) {
+            this.moveListeners.push(listener);
+        }
+    }
+
+    public offMove(listener: MoveListener) {
+        this.removeListener(this.moveListeners, listener);
+    }
+
+    public onConfirm(listener: ConfirmListener) {
+        if (listener && this.confirmListeners.indexOf(listener) < 0) {
+            this.confirmListeners.push(listener);
+        }
+    }
+
+    public offConfirm(listener: ConfirmListener) {
+        this.removeListener(this.confirmListeners, listener);
+    }
+
+    public onStatus(listener: StatusListener) {
+        if (listener && this.statusListeners.indexOf(listener) < 0) {
+            this.statusListeners.push(listener);
+        }
+    }
+
+    public offStatus(listener: StatusListener) {
+        this.removeListener(this.statusListeners, listener);
+    }
+
+    public onControl(listener: ControlListener) {
+        if (listener && this.controlListeners.indexOf(listener) < 0) {
+            this.controlListeners.push(listener);
+        }
+    }
+
+    public offControl(listener: ControlListener) {
+        this.removeListener(this.controlListeners, listener);
+    }
+
+    public onStick(listener: ControlListener) {
+        if (listener && this.stickListeners.indexOf(listener) < 0) {
+            this.stickListeners.push(listener);
+        }
+    }
+
+    public offStick(listener: ControlListener) {
+        this.removeListener(this.stickListeners, listener);
+    }
+
+    public onButton(listener: ControlListener) {
+        if (listener && this.buttonListeners.indexOf(listener) < 0) {
+            this.buttonListeners.push(listener);
+        }
+    }
+
+    public offButton(listener: ControlListener) {
+        this.removeListener(this.buttonListeners, listener);
+    }
+
+    public onShoulder(listener: ControlListener) {
+        if (listener && this.shoulderListeners.indexOf(listener) < 0) {
+            this.shoulderListeners.push(listener);
+        }
+    }
+
+    public offShoulder(listener: ControlListener) {
+        this.removeListener(this.shoulderListeners, listener);
+    }
+
+    public onBack(listener: ControlListener) {
+        if (listener && this.backListeners.indexOf(listener) < 0) {
+            this.backListeners.push(listener);
+        }
+    }
+
+    public offBack(listener: ControlListener) {
+        this.removeListener(this.backListeners, listener);
+    }
+
+    private handleClientState(state: VirtualGamepadConnectionState, reason?: string) {
+        this.connectionState = state;
+        if (state == "error") {
+            this.lastError = reason || "连接失败";
+        }
+        if (state == "closed" || state == "error") {
+            this.controllerConnected = false;
+            this.emitMove({ x: 0, y: 0 });
+        }
+        this.emitStatus();
+    }
+
+    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.emitStatus();
+            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.emitMove({ 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);
+        if (payload && this.handleStandardInput(message, payload)) {
+            return;
+        }
+        if (payload.action == "move" || payload.action == "stop") {
+            this.emitMove({
+                x: this.clampAxis(payload.action == "stop" ? 0 : Number(payload.x) || 0),
+                y: this.clampAxis(payload.action == "stop" ? 0 : Number(payload.y) || 0),
+                seq: seq,
+                ts: this.getMessageTimestamp(payload) || this.getMessageTimestamp(message),
+                raw: message
+            });
+            return;
+        }
+        if (payload.action == "confirm") {
+            let control = this.createControlInput("button", message, {
+                type: "button",
+                key: "confirm",
+                action: "press",
+                pressed: payload.pressed !== false
+            });
+            this.emitControl(control);
+            this.emitSpecificControl(control);
+            this.emitConfirm(payload.pressed !== false, message);
+        }
+    }
+
+    private handleStandardInput(message: any, input: any): boolean {
+        if (!input) return false;
+        if (input.type == "joystick" || input.type == "joystick_stick") {
+            let side = this.normalizeKey(input.side || "left");
+            let action = this.getInputAction(input);
+            let pressed = this.isPressedAction(input);
+            let vector = this.directionToVector(pressed ? input.direction : "");
+            let control = this.createControlInput("stick", message, {
+                type: "stick",
+                action: action,
+                pressed: pressed,
+                side: side,
+                direction: input.direction || "",
+                x: vector.x,
+                y: vector.y
+            });
+            this.emitControl(control);
+            this.emitSpecificControl(control);
+            if (side == "left") {
+                let rawInput = message.input || message;
+                this.emitMove({
+                    x: vector.x,
+                    y: vector.y,
+                    seq: typeof rawInput.seq == "number" ? rawInput.seq : message.seq,
+                    ts: this.getMessageTimestamp(rawInput) || this.getMessageTimestamp(message),
+                    raw: message,
+                    holdMode: true,
+                    stopTimeoutMs: 0,
+                    side: side,
+                    direction: input.direction || "",
+                    action: action
+                });
+            }
+            return true;
+        }
+        if (input.type == "button") {
+            let key = this.normalizeKey(input.key);
+            let control = this.createControlInput(key == "back" ? "back" : "button", message, {
+                type: key == "back" ? "back" : "button",
+                action: this.getInputAction(input),
+                pressed: this.isPressedAction(input),
+                key: key
+            });
+            this.emitControl(control);
+            this.emitSpecificControl(control);
+            if (key == "confirm" || key == "a") {
+                this.emitConfirm(control.pressed, message);
+            }
+            return true;
+        }
+        if (input.type == "shoulder") {
+            let control = this.createControlInput("shoulder", message, {
+                type: "shoulder",
+                action: this.getInputAction(input),
+                pressed: this.isPressedAction(input),
+                key: this.normalizeKey(input.key)
+            });
+            this.emitControl(control);
+            this.emitSpecificControl(control);
+            return true;
+        }
+        if (input.type == "back") {
+            let control = this.createControlInput("back", message, {
+                type: "back",
+                action: this.getInputAction(input),
+                pressed: this.isPressedAction(input),
+                key: "back"
+            });
+            this.emitControl(control);
+            this.emitSpecificControl(control);
+            return true;
+        }
+        return false;
+    }
+
+    private createControlInput(type: VirtualGamepadControlType, message: any, data: any): VirtualGamepadControlInput {
+        let rawInput = message && message.input ? message.input : message;
+        return {
+            type: type,
+            action: data.action || "press",
+            pressed: data.pressed !== false,
+            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 getInputAction(input: any): string {
+        return input && input.action ? String(input.action).toLowerCase() : "press";
+    }
+
+    private isPressedAction(input: any): boolean {
+        let action = this.getInputAction(input);
+        return action != "release" && action != "up" && action != "stop" && (!input || input.pressed !== false);
+    }
+
+    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) return false;
+        if (message.role == "game") return false;
+        if (message.type == "device_join" && this.isTargetPlayerMessage(message)) return true;
+        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" && this.isTargetPlayerMessage(message)) return true;
+        return ["peer_left", "player_left", "controller_left", "controller_disconnected", "leave"].indexOf(message.type) >= 0;
+    }
+
+    private handleRoomState(message: any) {
+        if (message.slots && message.slots.length) {
+            this.setControllerConnected(this.hasPlayerOneInList(message.slots));
+            return;
+        }
+        if (message.devices && message.devices.length) {
+            this.setControllerConnected(this.hasPlayerOneInList(message.devices));
+            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 playerId = this.getMessagePlayerId(message);
+        return !playerId || playerId == 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;
+        for (let i = 0; i < list.length; i++) {
+            let item = list[i];
+            if (item && item.role == VIRTUAL_GAMEPAD_PLAYER_ID && item.occupied !== false) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private directionToVector(direction: string): { x: number, y: number } {
+        let value = String(direction || "").toLowerCase();
+        let x = 0;
+        let y = 0;
+        if (value.indexOf("left") >= 0) x -= 1;
+        if (value.indexOf("right") >= 0) x += 1;
+        if (value.indexOf("up") >= 0) y += 1;
+        if (value.indexOf("down") >= 0) y -= 1;
+        return { x: x, y: y };
+    }
+
+    private getMessageTimestamp(message: any): number {
+        if (typeof message.ts == "number") return message.ts;
+        if (typeof message.timestamp == "number") return message.timestamp;
+        return 0;
+    }
+
+    private setControllerConnected(connected: boolean) {
+        if (this.controllerConnected == connected) return;
+        this.controllerConnected = connected;
+        if (!connected) {
+            this.emitMove({ x: 0, y: 0 });
+        }
+        this.emitStatus();
+    }
+
+    private emitMove(input: VirtualGamepadMoveInput) {
+        for (let i = this.moveListeners.length - 1; i >= 0; i--) {
+            this.moveListeners[i](input);
+        }
+    }
+
+    private emitConfirm(pressed: boolean, raw?: any) {
+        for (let i = this.confirmListeners.length - 1; i >= 0; i--) {
+            this.confirmListeners[i](pressed, raw);
+        }
+    }
+
+    private emitControl(input: VirtualGamepadControlInput) {
+        for (let i = this.controlListeners.length - 1; i >= 0; i--) {
+            this.controlListeners[i](input);
+        }
+    }
+
+    private emitSpecificControl(input: VirtualGamepadControlInput) {
+        let list: ControlListener[] = [];
+        if (input.type == "stick") list = this.stickListeners;
+        if (input.type == "button") list = this.buttonListeners;
+        if (input.type == "shoulder") list = this.shoulderListeners;
+        if (input.type == "back") list = this.backListeners;
+        for (let i = list.length - 1; i >= 0; i--) {
+            list[i](input);
+        }
+    }
+
+    private emitStatus() {
+        let status = this.getStatus();
+        for (let i = this.statusListeners.length - 1; i >= 0; i--) {
+            this.statusListeners[i](status);
+        }
+    }
+
+    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: { [key: string]: string }): string {
+        let query = [];
+        for (let key in params) {
+            query.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key] || ""));
+        }
+        let queryString = query.join("&");
+        let hashIndex = url.indexOf("#");
+        if (hashIndex >= 0) {
+            let prefix = url.substring(0, hashIndex);
+            let hash = url.substring(hashIndex + 1);
+            let separator = hash.indexOf("?") >= 0 ? "&" : "?";
+            return prefix + "#" + hash + separator + queryString;
+        }
+        let separator = url.indexOf("?") >= 0 ? "&" : "?";
+        return url + separator + queryString;
+    }
+
+    private clampAxis(value: number): number {
+        if (value > 1) return 1;
+        if (value < -1) return -1;
+        return value;
+    }
+
+    private removeListener<T>(list: T[], listener: T) {
+        let index = list.indexOf(listener);
+        if (index >= 0) {
+            list.splice(index, 1);
+        }
+    }
+
+    private getOrCreateDeviceId(): string {
+        let key = "rxqs_virtual_gamepad_device_id";
+        try {
+            let localStorage = cc.sys && cc.sys.localStorage;
+            if (localStorage) {
+                let saved = localStorage.getItem(key);
+                if (saved) return saved;
+                let created = this.createId("game");
+                localStorage.setItem(key, created);
+                return created;
+            }
+        } catch (e) {
+        }
+        return this.createId("game");
+    }
+
+    private requestSunCode() {
+        let requestSerial = ++this.sunCodeRequestSerial;
+        this.sunCodeState = "loading";
+        this.sunCodeDataUrl = "";
+        this.sunCodeError = "";
+        this.emitStatus();
+
+        let xhr = new XMLHttpRequest();
+        xhr.timeout = 10000;
+        let wxacodeUrl = VirtualGamepadConfig.getWxacodeUrl();
+        xhr.open("POST", wxacodeUrl, true);
+        xhr.responseType = "arraybuffer";
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.onload = () => {
+            if (requestSerial != this.sunCodeRequestSerial || !this.started) return;
+            if (xhr.status < 200 || xhr.status >= 300 || !xhr.response) {
+                this.failSunCode("太阳码接口返回 " + xhr.status, requestSerial);
+                return;
+            }
+            let bytes = new Uint8Array(xhr.response as ArrayBuffer);
+            let mimeType = this.detectImageMimeType(bytes);
+            if (!mimeType) {
+                this.failSunCode("太阳码接口未返回有效图片", requestSerial);
+                return;
+            }
+            this.sunCodeDataUrl = "data:" + mimeType + ";base64," + this.encodeBase64(bytes);
+            this.sunCodeState = "ready";
+            this.sunCodeError = "";
+            console.log("[VirtualGamepad][SunCode] ready", {
+                environment: VirtualGamepadConfig.getEnvironment(),
+                url: wxacodeUrl,
+                roomId: this.roomId,
+                page: VIRTUAL_GAMEPAD_WXACODE_PAGE,
+                projectCode: VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE,
+                byteLength: bytes.length,
+                mimeType: mimeType
+            });
+            this.emitStatus();
+        };
+        xhr.onerror = () => this.failSunCode("太阳码接口网络错误", requestSerial);
+        xhr.ontimeout = () => this.failSunCode("太阳码接口请求超时", requestSerial);
+        xhr.send(JSON.stringify({
+            scene: this.roomId,
+            page: VIRTUAL_GAMEPAD_WXACODE_PAGE,
+            projectCode: VIRTUAL_GAMEPAD_WXACODE_PROJECT_CODE
+        }));
+    }
+
+    private failSunCode(message: string, requestSerial: number) {
+        if (requestSerial != this.sunCodeRequestSerial || !this.started) return;
+        this.sunCodeState = "error";
+        this.sunCodeDataUrl = "";
+        this.sunCodeError = message;
+        console.warn("[VirtualGamepad][SunCode] unavailable", {
+            roomId: this.roomId,
+            message: message
+        });
+        this.emitStatus();
+    }
+
+    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 output = "";
+        for (let i = 0; i < bytes.length; i += 3) {
+            let first = bytes[i];
+            let second = i + 1 < bytes.length ? bytes[i + 1] : 0;
+            let third = i + 2 < bytes.length ? bytes[i + 2] : 0;
+            output += chars.charAt(first >> 2);
+            output += chars.charAt(((first & 3) << 4) | (second >> 4));
+            output += i + 1 < bytes.length ? chars.charAt(((second & 15) << 2) | (third >> 6)) : "=";
+            output += i + 2 < bytes.length ? chars.charAt(third & 63) : "=";
+        }
+        return output;
+    }
+
+    private resolveIdentity(): VirtualGamepadIdentity {
+        // try {
+        //     let userVo = GameVoManager.getInstance.myUserVo;
+        //     let userId = userVo && userVo.lvUid ? String(userVo.lvUid).trim() : "";
+        //     if (userVo && userVo.isAuthorize == 1 && userId) {
+        //         return { userId: userId, userType: "xiaomi" };
+        //     }
+        // } catch (e) {
+        // }
+        // 注释掉的用户id，使用游客id
+        let guestId = this.getOrCreateGuestId();
+        return { userId: guestId, userType: "guest", guestId: guestId };
+    }
+
+    private getOrCreateGuestId(): string {
+        let key = "rxqs_virtual_gamepad_guest_id";
+        try {
+            let localStorage = cc.sys && cc.sys.localStorage;
+            if (localStorage) {
+                let saved = localStorage.getItem(key);
+                if (saved) return saved;
+                let created = this.createId("guest");
+                localStorage.setItem(key, created);
+                return created;
+            }
+        } catch (e) {
+        }
+        return this.createId("guest");
+    }
+
+    private getIdentityText(): string {
+        let label = this.identity.userType == "xiaomi" ? "小米用户" : "游客";
+        return label + " " + this.maskUserId(this.identity.userId);
+    }
+
+    private maskUserId(userId: string): string {
+        let value = String(userId || "");
+        if (value.length <= 8) return value;
+        return value.substring(0, 4) + "..." + value.substring(value.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);
+    }
+}