drgame-cc 1.0.17 → 1.0.19

package/drscript/focus/FocusManager.ts

@@ -450,16 +450,16 @@ export default class FocusManager {
 
     private static invokeButton(button: cc.Button) {
         if (!button || !button.node || !button.node.activeInHierarchy || !button.interactable) return;
+        var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
+        event.target = button.node;
         if (button.clickEvents && button.clickEvents.length > 0) {
-            cc.Component.EventHandler.emitEvents(button.clickEvents, null);
-
-            var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
-            button.node.emit(cc.Node.EventType.TOUCH_END, event);
-        } else {
-            // 模拟一个touch end事件
-            var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
-            button.node.emit(cc.Node.EventType.TOUCH_END, event);
+            cc.Component.EventHandler.emitEvents(button.clickEvents, event);
+        }
+        if (button instanceof cc.Toggle) {
+            button.isChecked = !button.isChecked;
+            cc.Component.EventHandler.emitEvents(button.checkEvents, event);
         }
+        button.node.emit(cc.Node.EventType.TOUCH_END, event);
     }
 
     private static emitFocusChanged(item: FocusRuntimeItem | null, previous?: FocusRuntimeItem | null) {

package/drscript/focus/FocusVisualLayer.ts

@@ -167,59 +167,59 @@ export default class FocusVisualLayer extends cc.Component {
         this.graphics.stroke();
     }
 
-    private positionIcon(item: FocusRuntimeItem, iconConfig: TvUiIconItem) {
-        if (!item || !item.node || !item.node.isValid) return;
-        let focusConfig = TvUiConfigManager.getConfig().focus || {};
-
-        let node = item.node;
-        let worldPos = node.parent.convertToWorldSpaceAR(node.position);
-        let local = this.node.convertToNodeSpaceAR(worldPos);
-
-        let contentSize = node.getContentSize();
-        let scaleX = node.scaleX;
-        let scaleY = node.scaleY;
-        let width = contentSize.width * scaleX;
-        let height = contentSize.height * scaleY;
-
-        let iconWidth = iconConfig.width || 60;
-        let iconHeight = iconConfig.height || 60;
-        let offsetX = iconConfig.offsetX;
-        let offsetY = iconConfig.offsetY;
-        if (offsetX === undefined) offsetX = focusConfig.iconOffsetX || 0;
-        if (offsetY === undefined) offsetY = focusConfig.iconOffsetY || 0;
-        if (!this.iconNode) return;
-
-        let x = local.x + width / 2 + offsetX;
-        let y = local.y + height / 2 + offsetY;
-        if ((focusConfig.iconPlacement || "bottomRight") == "bottomRight") {
-            y = local.y - height / 2 - offsetY;
-        }
-        this.iconNode.setContentSize(iconWidth, iconHeight);
-        this.iconNode.setPosition(x, y);
-    }
-
     // private positionIcon(item: FocusRuntimeItem, iconConfig: TvUiIconItem) {
     //     if (!item || !item.node || !item.node.isValid) return;
     //     let focusConfig = TvUiConfigManager.getConfig().focus || {};
-    //     let box = item.node.getBoundingBoxToWorld();
-    //     let center = cc.v2(box.x + box.width / 2, box.y + box.height / 2);
-    //     let local = this.node.convertToNodeSpaceAR(center);
-    //     let width = iconConfig.width || 60;
-    //     let height = iconConfig.height || 60;
+
+    //     let node = item.node;
+    //     let worldPos = node.parent.convertToWorldSpaceAR(node.position);
+    //     let local = this.node.convertToNodeSpaceAR(worldPos);
+
+    //     let contentSize = node.getContentSize();
+    //     let scaleX = node.scaleX;
+    //     let scaleY = node.scaleY;
+    //     let width = contentSize.width * scaleX;
+    //     let height = contentSize.height * scaleY;
+
+    //     let iconWidth = iconConfig.width || 60;
+    //     let iconHeight = iconConfig.height || 60;
     //     let offsetX = iconConfig.offsetX;
     //     let offsetY = iconConfig.offsetY;
     //     if (offsetX === undefined) offsetX = focusConfig.iconOffsetX || 0;
     //     if (offsetY === undefined) offsetY = focusConfig.iconOffsetY || 0;
     //     if (!this.iconNode) return;
-    //     let x = local.x + box.width / 2 + offsetX;
-    //     let y = local.y + box.height / 2 + offsetY;
+
+    //     let x = local.x + width / 2 + offsetX;
+    //     let y = local.y + height / 2 + offsetY;
     //     if ((focusConfig.iconPlacement || "bottomRight") == "bottomRight") {
-    //         y = local.y - box.height / 2 - offsetY;
+    //         y = local.y - height / 2 - offsetY;
     //     }
-    //     this.iconNode.setContentSize(width, height);
+    //     this.iconNode.setContentSize(iconWidth, iconHeight);
     //     this.iconNode.setPosition(x, y);
     // }
 
+    private positionIcon(item: FocusRuntimeItem, iconConfig: TvUiIconItem) {
+        if (!item || !item.node || !item.node.isValid) return;
+        let focusConfig = TvUiConfigManager.getConfig().focus || {};
+        let box = item.node.getBoundingBoxToWorld();
+        let center = cc.v2(box.x + box.width / 2, box.y + box.height / 2);
+        let local = this.node.convertToNodeSpaceAR(center);
+        let width = iconConfig.width || 60;
+        let height = iconConfig.height || 60;
+        let offsetX = iconConfig.offsetX;
+        let offsetY = iconConfig.offsetY;
+        if (offsetX === undefined) offsetX = focusConfig.iconOffsetX || 0;
+        if (offsetY === undefined) offsetY = focusConfig.iconOffsetY || 0;
+        if (!this.iconNode) return;
+        let x = local.x + box.width / 2 + offsetX;
+        let y = local.y + box.height / 2 + offsetY;
+        if ((focusConfig.iconPlacement || "bottomRight") == "bottomRight") {
+            y = local.y - box.height / 2 - offsetY;
+        }
+        this.iconNode.setContentSize(width, height);
+        this.iconNode.setPosition(x, y);
+    }
+
     private resizeToParent() {
         let parent = this.node.parent;
         let width = parent && parent.width ? parent.width : (cc.winSize && cc.winSize.width) || 1920;

package/drscript/input/KeyboardMove.ts

@@ -0,0 +1,55 @@
+import TvUi from "../core/TvUi";
+import { TvRemoteKey } from "./KeyCodeAdapter";
+
+const { ccclass, property } = cc._decorator;
+
+@ccclass
+export default class KeyboardMove extends cc.Component {
+    /**
+     * 按键移动回调
+     */
+    public callback: (dir: cc.Vec2) => void;
+    private _keys: Set<TvRemoteKey> = new Set();
+    private _dir: cc.Vec2 = cc.v2(0, 0);
+
+    onLoad(): void {
+        cc.systemEvent.on(cc.SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
+        cc.systemEvent.on(cc.SystemEvent.EventType.KEY_UP, this.onKeyUp, this);
+    }
+
+    onDestroy(): void {
+        cc.systemEvent.off(cc.SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
+        cc.systemEvent.off(cc.SystemEvent.EventType.KEY_UP, this.onKeyUp, this);
+        this._keys.clear();
+    }
+
+    private onKeyDown(event: cc.Event.EventKeyboard): void {
+        let key = TvUi.input.toRemoteKey(event.keyCode);
+        this._keys.add(key);
+    }
+
+    private onKeyUp(event: cc.Event.EventKeyboard): void {
+        let key = TvUi.input.toRemoteKey(event.keyCode);
+        this._keys.delete(key);
+    }
+
+    update(dt: number): void {
+        if (this._keys.size === 0)
+            return;
+
+        const dir = this._dir;
+        dir.x = 0;
+        dir.y = 0;
+
+        if (this._keys.has(TvRemoteKey.Left)) dir.x -= 1;
+        if (this._keys.has(TvRemoteKey.Right)) dir.x += 1;
+        if (this._keys.has(TvRemoteKey.Down)) dir.y -= 1;
+        if (this._keys.has(TvRemoteKey.Up)) dir.y += 1;
+
+        if (dir.x !== 0 || dir.y !== 0) {
+            dir.normalizeSelf();
+        }
+
+        if (this.callback) this.callback(dir);
+    }
+}

package/drscript/virtualgamepad/VirtualGamepadClient.ts

@@ -0,0 +1,214 @@
+export interface VirtualGamepadClientOptions {
+    wsUrl: string;
+    roomId: string;
+    deviceId: string;
+    game: string;
+    userId: string;
+    userType: "xiaomi" | "guest";
+    guestId?: string;
+    token?: string;
+    maxMembers: number;
+}
+
+export type VirtualGamepadConnectionState = "idle" | "connecting" | "open" | "joined" | "closed" | "error";
+
+export default class VirtualGamepadClient {
+    private socket: WebSocket | null = null;
+    private options: VirtualGamepadClientOptions | 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: VirtualGamepadClientOptions) {
+        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) {
+            }
+        }
+        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 options = this.options;
+        let query: { [key: string]: string } = {
+            roomId: options.roomId,
+            deviceId: options.deviceId,
+            role: "game",
+            userId: options.userId,
+            userType: options.userType,
+            maxMembers: String(options.maxMembers)
+        };
+        if (options.guestId) query.guestId = options.guestId;
+        if (options.token) query.token = options.token;
+        let url = this.appendParams(options.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 joinMessage: 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) joinMessage.guestId = this.options.guestId;
+        if (this.options.token) joinMessage.token = this.options.token;
+        console.log("[VirtualGamepad][WSS][Send] join", {
+            type: joinMessage.type,
+            roomId: joinMessage.roomId,
+            role: joinMessage.role,
+            deviceId: joinMessage.deviceId,
+            userId: joinMessage.userId,
+            userType: joinMessage.userType,
+            guestId: joinMessage.guestId || "",
+            maxMembers: joinMessage.maxMembers,
+            game: joinMessage.game,
+            hasToken: !!joinMessage.token
+        });
+        this.send(joinMessage);
+        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: { [key: string]: string }): string {
+        let query = [];
+        for (let key in params) {
+            query.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key] || ""));
+        }
+        let separator = url.indexOf("?") >= 0 ? "&" : "?";
+        return url + separator + query.join("&");
+    }
+
+    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;
+        }
+    }
+}

package/drscript/virtualgamepad/VirtualGamepadClient.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "dc301a42-a41d-4d44-bf7b-9f6bdde0230f",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/virtualgamepad/VirtualGamepadConfig.ts

@@ -0,0 +1,70 @@
+export const VIRTUAL_GAMEPAD_GAME_ID = "rexueqiangshou";
+declare const global: any;
+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";
+
+export default class VirtualGamepadConfig {
+    public static getWsUrl(): string {
+        return this.getRuntimeValue("RXQS_GAMEPAD_WS_URL") ||
+            (this.getEnvironment() == "production" ? VIRTUAL_GAMEPAD_PRODUCTION_WS_URL : VIRTUAL_GAMEPAD_DEVELOPMENT_WS_URL);
+    }
+
+    public static getWxacodeUrl(): string {
+        return this.getRuntimeValue("RXQS_GAMEPAD_WXACODE_URL") ||
+            (this.getEnvironment() == "production" ? VIRTUAL_GAMEPAD_PRODUCTION_WXACODE_URL : VIRTUAL_GAMEPAD_DEVELOPMENT_WXACODE_URL);
+    }
+
+    public static getEnvironment(): VirtualGamepadEnvironment {
+        let environment = this.getRuntimeValue("RXQS_GAMEPAD_ENVIRONMENT");
+        if (environment == "development" || environment == "production") {
+            return environment;
+        }
+        if (environment == "test") {
+            return "development";
+        }
+        return VIRTUAL_GAMEPAD_DEFAULT_ENVIRONMENT;
+    }
+
+    public static getH5Url(): string {
+        return this.getRuntimeValue("RXQS_GAMEPAD_H5_URL") || VIRTUAL_GAMEPAD_H5_URL;
+    }
+
+    public static getRoomId(): string {
+        return this.getRuntimeValue("RXQS_GAMEPAD_ROOM_ID");
+    }
+
+    public static getToken(): string {
+        return this.getRuntimeValue("RXQS_GAMEPAD_TOKEN");
+    }
+
+    public static getQrMode(): VirtualGamepadQrMode {
+        let mode = this.getRuntimeValue("RXQS_GAMEPAD_QR_MODE");
+        return mode == "json" ? "json" : VIRTUAL_GAMEPAD_QR_MODE;
+    }
+
+    private static 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) {
+        }
+        return "";
+    }
+}

package/drscript/virtualgamepad/VirtualGamepadConfig.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "19522c5f-96b0-448d-bc57-07193079940d",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}