feat:

assets/op_16/GOBE/GOBE.js.meta

-{
-  "ver": "1.0.8",
-  "uuid": "19c7da79-785a-4dac-832d-a205dd7b9468",
-  "isPlugin": true,
-  "loadPluginInWeb": true,
-  "loadPluginInNative": true,
-  "loadPluginInEditor": false,
-  "subMetas": {}
-}
\ No newline at end of file

assets/op_16/GOBE/package.json

-{
-  "type": "software",
-  "scope": "game",
-  "name": "GameOBESDK",
-  "version": "1.1.5.300",
-  "playbook": ""
-}
\ No newline at end of file

assets/op_16/GOBE/package.json.meta

-{
-  "ver": "1.0.0",
-  "uuid": "68d46fb9-7d79-4b81-b649-530ebfebeb02",
-  "subMetas": {}
-}
\ No newline at end of file

assets/op_16/GOBE.meta → assets/op_16/leanCloud.meta

 {
   "ver": "1.1.2",
-  "uuid": "cef41626-c90e-41f1-a964-e90cb843baab",
+  "uuid": "f1692c2c-d67a-4ab2-b035-f55e68326faa",
   "isBundle": false,
   "bundleName": "",
   "priority": 1,

assets/op_16/leanCloud/play.d.ts

+export as namespace Play;
+
+declare class EventEmitter<T> {
+  on<K extends keyof T>(event: K, listener: (payload: T[K]) => any): this;
+
+  on(evt: string, listener: Function): this;
+
+  once<K extends keyof T>(event: K, listener: (payload: T[K]) => any): this;
+
+  once(evt: string, listener: Function): this;
+
+  off<K extends keyof T>(evt: K | string, listener?: Function): this;
+
+  emit<K extends keyof T>(evt: K | string, ...args: any[]): boolean;
+}
+
+export enum Event {
+  /** 断开连接 */
+  DISCONNECTED = 'disconnected',
+  /** 加入到大厅 */
+  LOBBY_JOINED = 'lobbyJoined',
+  /** 大厅房间列表变化 */
+  LOBBY_ROOM_LIST_UPDATED = 'lobbyRoomListUpdate',
+  /** 有新玩家加入房间 */
+  PLAYER_ROOM_JOINED = 'newPlayerJoinedRoom',
+  /** 有玩家离开房间 */
+  PLAYER_ROOM_LEFT = 'playerLeftRoom',
+  /** 玩家活跃属性变化 */
+  PLAYER_ACTIVITY_CHANGED = 'playerActivityChanged',
+  /** 主机变更 */
+  MASTER_SWITCHED = 'masterSwitched',
+  /** 离开房间 */
+  ROOM_LEFT = 'roomLeft',
+  /** 被踢出房间 */
+  ROOM_KICKED = 'roomKicked',
+  /** 房间系统属性变化 */
+  ROOM_SYSTEM_PROPERTIES_CHANGED = 'roomSystemPropertiesChanged',
+  /** 房间自定义属性变化 */
+  ROOM_CUSTOM_PROPERTIES_CHANGED = 'roomCustomPropertiesChanged',
+  /** 玩家自定义属性变化 */
+  PLAYER_CUSTOM_PROPERTIES_CHANGED = 'playerCustomPropertiesChanged',
+  /** 自定义事件 */
+  CUSTOM_EVENT = 'customEvent',
+  /** 错误事件 */
+  ERROR = 'error',
+}
+
+export enum ReceiverGroup {
+  /** 其他人（除了自己之外的所有人） */
+  Others,
+  /** 所有人（包括自己） */
+  All,
+  /** 主机客户端 */
+  MasterClient,
+}
+
+interface CustomProperties {
+  [key: string]: any;
+}
+
+interface CustomEventData {
+  [key: string]: any;
+}
+
+interface ErrorEvent {
+  code: number;
+  detail: string;
+}
+
+declare interface PlayEvent {
+  connected: void;
+  connectFailed: ErrorEvent;
+  disconnected: void;
+  lobbyJoined: void;
+  lobbyLeft: void;
+  lobbyRoomListUpdate: void;
+  roomCreated: void;
+  roomCreateFailed: ErrorEvent;
+  roomJoined: void;
+  roomJoinFailed: ErrorEvent;
+  newPlayerJoinedRoom: {
+    newPlayer: Player;
+  };
+  playerLeftRoom: {
+    leftPlayer: Player;
+  };
+  playerActivityChanged: {
+    player: Player;
+  };
+  masterSwitched: {
+    newMaster: Player;
+  };
+  roomLeft: void;
+  roomKicked: {
+    code: number;
+    msg: string;
+  };
+  roomCustomPropertiesChanged: {
+    changedProps: CustomProperties;
+  };
+  roomSystemPropertiesChanged: {
+    changedProps: CustomProperties;
+  };
+  playerCustomPropertiesChanged: {
+    player: Player;
+    changedProps: CustomProperties;
+  };
+  customEvent: {
+    eventId: number;
+    eventData: CustomEventData;
+    senderId: number;
+  };
+  error: ErrorEvent;
+}
+
+export class LobbyRoom {
+  readonly roomName: string;
+
+  readonly maxPlayerCount: number;
+
+  readonly expectedUserIds: string[];
+
+  readonly emptyRoomTtl: number;
+
+  readonly playerTtl: number;
+
+  readonly playerCount: number;
+
+  readonly customRoomPropertiesForLobby: CustomProperties;
+}
+
+export class Player {
+  readonly userId: string;
+
+  readonly actorId: number;
+
+  readonly isLocal: boolean;
+
+  readonly isMaster: boolean;
+
+  readonly isActive: boolean;
+
+  setCustomProperties(
+    properties: CustomProperties,
+    opts?: {
+      expectedValues?: CustomProperties;
+    }
+  ): Promise<void>;
+
+  readonly customProperties: CustomProperties;
+}
+
+export class Room {
+  readonly name: string;
+
+  readonly open: boolean;
+
+  readonly visible: boolean;
+
+  readonly maxPlayerCount: number;
+
+  readonly master: Player;
+
+  readonly masterId: number;
+
+  readonly expectedUserIds: string[];
+
+  readonly playerList: Player[];
+
+  getPlayer(actorId: number): Player;
+
+  setCustomProperties(
+    properties: CustomProperties,
+    opts?: {
+      expectedValues?: CustomProperties;
+    }
+  ): Promise<void>;
+
+  readonly customProperties: CustomProperties;
+
+  setOpen(open: boolean): Promise<void>;
+
+  setVisible(visible: boolean): Promise<void>;
+
+  setRoomMaxPlayerCount(count: number): Promise<void>;
+
+  setRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  clearRoomExpectedUserIds(): Promise<void>;
+
+  addRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  removeRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  setMaster(newMasterId: number): Promise<void>;
+
+  sendEvent(
+    eventId: number,
+    eventData?: CustomEventData,
+    options?: {
+      receiverGroup?: ReceiverGroup;
+      targetActorIds?: number[];
+    }
+  ): Promise<void>;
+
+  kickPlayer(
+    actorId: number,
+    opts?: {
+      code?: number;
+      msg?: string;
+    }
+  ): Promise<void>;
+
+  leave(): Promise<void>;
+}
+
+export class Client extends EventEmitter<PlayEvent> {
+  readonly room: Room;
+
+  readonly player: Player;
+
+  readonly lobbyRoomList: LobbyRoom[];
+
+  userId: string;
+
+  constructor(opts: {
+    appId: string;
+    appKey: string;
+    userId: string;
+    ssl?: boolean;
+    feature?: string;
+    gameVersion?: string;
+    playServer?: string;
+  });
+
+  connect(): Promise<Client>;
+
+  reconnect(): Promise<Client>;
+
+  reconnectAndRejoin(): Promise<Room>;
+
+  close(): Promise<void>;
+
+  joinLobby(): Promise<void>;
+
+  leaveLobby(): Promise<void>;
+
+  createRoom(opts?: {
+    roomName?: string;
+    roomOptions?: Object;
+    expectedUserIds?: string[];
+  }): Promise<Room>;
+
+  joinRoom(
+    roomName: string,
+    opts?: {
+      expectedUserIds?: string[];
+    }
+  ): Promise<Room>;
+
+  rejoinRoom(roomName: string): Promise<Room>;
+
+  joinOrCreateRoom(
+    roomName: string,
+    opts?: {
+      roomOptions?: Object;
+      expectedUserIds: string[];
+    }
+  ): Promise<Room>;
+
+  joinRandomRoom(opts?: {
+    matchProperties?: Object;
+    expectedUserIds?: string[];
+  }): Promise<Room>;
+
+  matchRandom(
+    piggybackPeerId: string,
+    opts?: { matchProperties?: Object; expectedUserIds?: string[] }
+  ): Promise<LobbyRoom>;
+
+  setRoomOpen(open: boolean): Promise<void>;
+
+  setRoomVisible(visible: boolean): Promise<void>;
+
+  setRoomMaxPlayerCount(count: number): Promise<void>;
+
+  setRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  clearRoomExpectedUserIds(): Promise<void>;
+
+  addRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  removeRoomExpectedUserIds(expectedUserIds: string[]): Promise<void>;
+
+  setMaster(newMasterId: number): Promise<void>;
+
+  sendEvent(
+    eventId: number,
+    eventData?: CustomEventData,
+    options?: {
+      receiverGroup?: ReceiverGroup;
+      targetActorIds?: number[];
+    }
+  ): Promise<void>;
+
+  leaveRoom(): Promise<void>;
+
+  kickPlayer(
+    actorId: number,
+    opts?: {
+      code?: number;
+      msg?: string;
+    }
+  ): Promise<void>;
+
+  pauseMessageQueue(): void;
+  resumeMessageQueue(): void;
+}
+
+export enum CreateRoomFlag {
+  FixedMaster = 1,
+  MasterUpdateRoomProperties = 2,
+}
+
+export function setAdapters(newAdapters: { WebSocket: Function }): void;
+
+export enum LogLevel {
+  Debug = 'Debug',
+  Warn = 'Warn',
+  Error = 'Error',
+}
+
+export function setLogger(logger: {
+  Debug: (...args: any[]) => any;
+  Warn: (...args: any[]) => any;
+  Error: (...args: any[]) => any;
+}): void;
+
+export enum PlayErrorCode {
+  OPEN_WEBSOCKET_ERROR = 10001,
+  SEND_MESSAGE_STATE_ERROR = 10002,
+}
+
+export function registerType<T>(
+  type: T,
+  typeId: number,
+  serializeMethod: (obj: T) => Uint8Array,
+  deserializeMethod: (bytes: Uint8Array) => T
+): void;
+export function serializeObject(obj: Object): Uint8Array;
+export function deserializeObject(bytes: Uint8Array): Object;

assets/op_16/GOBE/GOBE.d.ts.meta → assets/op_16/leanCloud/play.d.ts.meta

 {
   "ver": "2.0.0",
-  "uuid": "b0e70fce-94a7-427f-b396-142d8f036737",
+  "uuid": "7d489752-af58-4be9-9ab6-2aeb77bfd3b9",
   "subMetas": {}
 }
\ No newline at end of file

assets/op_16/mgobejs/MGOBE.js.meta → assets/op_16/leanCloud/play.js.meta

 {
   "ver": "1.0.8",
-  "uuid": "f95ef923-1864-4251-886f-b8aae631d5cd",
+  "uuid": "6f6c1d55-4b39-4905-817a-ebd04a928c17",
   "isPlugin": true,
   "loadPluginInWeb": true,
   "loadPluginInNative": true,
-  "loadPluginInEditor": false,
+  "loadPluginInEditor": true,
   "subMetas": {}
 }
\ No newline at end of file

assets/op_16/mgobejs.meta

-{
-  "ver": "1.1.2",
-  "uuid": "7e76f46c-001c-42d7-ab08-a7608cc673f4",
-  "isBundle": false,
-  "bundleName": "",
-  "priority": 1,
-  "compressionType": {},
-  "optimizeHotUpdate": {},
-  "inlineSpriteFrames": {},
-  "isRemoteBundle": {},
-  "subMetas": {}
-}
\ No newline at end of file

assets/op_16/script/NetworkHelper.ts

@@ -29,16 +29,64 @@ export class NetworkHelper {
   room: any;
   client: any;
   async initRoom() {
-    this.client = {};
+    const client = new globalThis.Play.Client({
+      appId: "lyn5nahSjCX0gpuRPugoMILM-gzGzoHsz",
+      appKey: "Nh9qGdBHq7MGjPbgUoLxm8oG",
+      userId: `${new Date().getTime()}_${RandomInt(100000000)}`,
+      playServer: 'https://lyn5nahs.lc-cn-n1-shared.com'
+    });
+    console.log('client = ', client);
+    await client.connect();
+    this.client = client;
+    console.log('连接成功');
   }
 
   player: any;
-  async joinRoom(roomType: string, maxPlayers: number) {
-    const playerId = RandomInt(10000000);
-    this.room = new FakeRoom(playerId);
+  joinRoom(roomType: string, maxPlayers: number) {
+    return new Promise((resolve, reject) => {
+      const roomProp = { roomType, maxPlayers };
+      this.client.joinRandomRoom({
+        matchProperties: roomProp,
+      }).then((room) => {
+        resolve(this.onJoinRoomSuccess(room));
+      }).catch((error) => {
+        console.log('加入房间失败');
+        if (error.code == 4301) {
+          const options = {
+            visible: true,
+            playerTtl: 0,
+            emptyRoomTtl: 0,
+            maxPlayerCount: maxPlayers,
+            customRoomProperties: roomProp,
+            customRoomPropertyKeysForLobby: ['roomType', 'maxPlayers'],
+            flag: globalThis.Play.CreateRoomFlag.MasterUpdateRoomProperties
+          };
+          this.client.createRoom({
+            roomOptions: options,
+          }).then((room) => {
+            resolve(this.onJoinRoomSuccess(room));
+          }).catch((error) => {
+            console.error(error.code, error.detail);
+          });
+        }
+      });
+    });
+  }
+
+  onJoinRoomSuccess(room: globalThis.Play.Room) {
+    console.log('加入房间成功 room = ', room);
+    const playerMe = room.playerList.find(player => player.isLocal);
+    const masterPlayer = room.playerList.find(player => player.isMaster);
+    const masterId = masterPlayer.userId
+    const playerId = playerMe.userId;
+    this.room = new FakeRoom(masterId);
     this.room.players.push(this.room.player);
     this.player = this.room.player;
 
+    this.client.on(globalThis.Play.Event.PLAYER_ROOM_LEFT, (event) => {
+      this.room.on('Leave', event);
+    });
+
     this.room.onJoin(this.onJoinRoom.bind(this));
     this.room.onLeave(this.onLeaveRoom.bind(this));
     this.room.onStartFrameSync(this.onStartFrameSync.bind(this));
@@ -46,10 +94,7 @@ export class NetworkHelper {
     this.room.onRecvFrame(this.onRecvFrame.bind(this));
     this.room.onDisconnect(this.onDisconnect.bind(this));
     this.room.onDismiss(this.onDisconnect.bind(this));
-
-    await this.startFrameSync();
-
-    return this.player.playerId;
+    return playerId;
   }
 
   async leaveRoom() {
@@ -179,6 +224,24 @@ class FakeRoom {
     this.player = { playerId: playerId };
     this.ownerId = playerId;
   }
+
+  on(event, data) {
+    const eventNameList = [
+      'Leave',
+      'StartFrameSync',
+      'StopFrameSync',
+      'RecvFrame',
+      'Disconnect',
+      'Dismiss',
+    ];
+    eventNameList.forEach(eventName => {
+      if (event == eventName) {
+        const func = this[`_on${event}`];
+        func && func(data);
+      }
+    });
+  }
+
   _onJoin;
   onJoin(func: Function) {
     this._onJoin = func;

assets/op_16/script/runtime.js.meta

 {
   "ver": "1.0.8",
   "uuid": "b54300af-b8e5-4b4e-aa2f-9ac1cef7b598",
-  "isPlugin": true,
+  "isPlugin": false,
   "loadPluginInWeb": true,
   "loadPluginInNative": true,
   "loadPluginInEditor": false,