Client Engine 开发指南 · Node.js

请先阅读 Client Engine 快速入门 · Node.js 及你的第一个 Client Engine 小游戏来初步了解如何使用初始项目来开发游戏。本文档将在初始项目的基础上深入讲解 Client Engine SDK。

Client Engine 初始项目依赖了专门的 Client Engine SDK， Client Engine SDK 在多人在线对战 SDK 的基础上进行了封装，帮助您更好的撰写服务端游戏逻辑。您可以通过快速入门安装依赖。

组件

SDK 提供以下组件：

  • Game ：负责房间内游戏的具体逻辑。Client Engine 维护了许多游戏房间，每一个游戏房间都是一个 Game 实例，即每个 Game 实例对应一个唯一的 Play Room 与 MasterClient。游戏房间内的逻辑由 Game 中的代码来控制，因此房间内的游戏逻辑必须继承自该类。
  • GameManager ：负责创建、管理及分配具体的 Game 对象。Game 的管理及销毁由 SDK 负责，不需要您再自己额外写代码。

GameManager

GameManager 实例化

GameManager 会帮您自动创建、管理并销毁 Game，因此在项目启动时，您需要实例化 GameManager。相关示例代码如下：

自定义 GameManager

首先需要自定义一个 Class 继承自 GameManager，例如示例代码中的 SampleGameManager：

import { Game, GameManager, ICreateGameOptions } from "@leancloud/client-engine";
export default class SampleGameManager<T extends Game> extends GameManager<T> {

}
在 GameManager 中自定义方法

Client Engine 的核心用法之一是负责创建 Game 并返回 roomName 给客户端，因此在 SampleGameManager 这个类中，我们需要撰写创建 Game 的方法提供给 Web API 使用。例如示例项目中的快速开始和创建新游戏。这里的示例代码我们以创建新游戏为例：

import { Game, GameManager, ICreateGameOptions } from "@leancloud/client-engine";
export default class SampleGameManager<T extends Game> extends GameManager<T> {
  /**
   * 创建一个新的游戏。
   * @param playerId 预约的玩家 ID
   * @param options 创建新游戏时可以指定的一些配置项
   * @return 创建的游戏的房间 name
   */
  public async createGameAndGetName(playerId: string, options?: ICreateGameOptions) {
    const game = await this.createGame(playerId, options);
    return game.room.name;
  }
}

写完自定义方法之后，在下文我们还需要为这里的方法配置负载均衡，需要注意的是，受负载均衡系统的要求，GameManager 子类中的 public 方法，其参数与返回值必须是 string、number、boolean、null、Object、Array 中的一种。以上代码中可以看到 GameManager 的 createGame() 方法返回的是一个 Game，不符合负载均衡的要求，因此我们在这里封装为自己的方法 createGameAndGetName()。

创建 GameManager 子类对象

接下来创建 GameManager 的子类对象，在创建 SampleGameManager 的时候，需要在第一个参数内传入自定义的 Game ，这里使用的是示例 Demo 猜拳游戏中的 RPSGame。

import PRSGame from "./rps-game";
const gameManager = new SampleGameManager(
  gameConstructor: PRSGame,
  appId: {{appid}},
  appKey: {{appkey}},
  playServer: "https://please-replace-with-your-customized.domain.com",
  concurrency: 2,
);
设置负载均衡

GameManager 需要配置负载均衡，以确保 GameManager 创建的 Game 能够尽可能均匀分配到每一个 Client Engine 实例中。负载均衡的详细文档请看下文，在这里，我们先讲解如何配置。

在这里我们创建一个负载均衡对象，然后将上面的 gameManager 绑定到负载均衡中：

import { ICreateGameOptions,LoadBalancerFactory } from "@leancloud/client-engine";

// 创建负责负载均衡的对象，请不要更改，使用时复制粘贴即可
const loadBalancerFactory = new LoadBalancerFactory({
  poolId: `${APP_ID.slice(0, 5)}-${process.env.LEANCLOUD_APP_ENV || "development"}`,
  redisUrl: process.env.REDIS_URL__CLIENT_ENGINE,
});

// 将 reception 及我们自定义的方法 makeReservation 配置负载均衡。
const loadBalancer = loadBalancerFactory.bind(gameManager, ["createGameAndGetName"]);

loadBalancerFactory 的 bind() 方法中，第一个参数是 gameManager 对象，第二个参数是一个数组，传入需要进行负载均衡的方法名 ["createGameAndGetName"]。

到这里，gameManager 的配置就完成了，您可以在自己定义的 Web API 处这样调用相关方法： gameManager.createGameAndGetName()。

创建房间

在 GameManager 实例化这一节中，我们在子类中使用了 GameManager 的 createGame() 来创建房间。

createGame() 接受以下参数：

  • playerId：发起请求的客户端在多人对战服务中的 userId。
  • createGameOptions（可选）：创建指定条件的房间。
    • roomName（可选）：创建指定 roomName 的房间。例如您需要和好友一起玩时，可以用这个接口创建房间后，把 roomName 分享给好友。如果您不关心 roomName，可以不指定这个参数。
    • roomOptions（可选）：通过这个参数，客户端在请求 Client Engine 创建房间时，可以设置 customRoomProperties，customRoomPropertyKeysForLobby，visible，对这三个参数的说明请参考创建房间。
    • seatCount(可选)：创建房间时，指定本次游戏需要多少人，这个值需要在设置房间内玩家数量的 minSeatCount 和 maxSeatCount 之间，否则 Client Engine 会拒绝创建房间。如果不指定，则以 defaultSeatCount 为准。

例如创建一个带有匹配条件的新房间时，可以这样调用 createGame()：

// 您可以从客户端发来的请求中获得 playerId 和 createGameOptions
const props = {
    level: 2,
};

const roomOptions = {
  customRoomPropertyKeysForLobby: ['level'],
  customRoomProperties: props,
};

const createGameOptions = {
  roomOptions
};

gameManager.createGame(playerId, createGameOptions);

在你的第一个 Client Engine 小游戏中，reception.ts 中使用 createGame() 撰写了两个自定义方法用于「快速开始」和「创建新游戏」，并通过 index.ts 中的 Web API /reservation 和 /game 来调用相关逻辑，如果没有自定义需求您可以直接使用示例 Demo 中的接口并传入以上参数。

获取当前可用的房间

GameManager 提供了 getAvailableGames() 方法来获取当前 GameManager 对象所在的 Client Engine 实例中的可用游戏列表。这里的可用指的是房间还有空位。使用示例代码如下：

var games = gameManager.getAvailableGames();

需要注意的是，这个方法获取的不是多人对战服务中所有的可用房间，仅限于当前所在 Client Engine 实例中的可用房间，Client Engine 多实例负载均衡请参考负载均衡。

匹配

GameManager 暂时没有提供匹配机制，如果客户端只需要随机加入某个房间，可以参考示例项目中「快速开始」的实现方案。这个实现方案会在负载最低的实例中寻找可用房间或创建房间，最终返回给客户端一个可加入的房间名称。

如果您希望实现有条件的匹配，可以这样实现：

  1. 客户端向多人对战服务请求有条件的匹配，如果有空余的房间，则会触发加入成功事件。
  2. 如果的多人对战服务此时没有空余的房间，客户端会收到「加入房间失败」事件，在这个事件中，发现错误码是 4301，则向 Client Engine 请求创建房间。
  3. Client Engine 收到请求后创建房间并返回 roomName 给客户端。这一部分的逻辑可以使用示例项目中的 /game 入口。
  4. 客户端拿到 Client Engine 返回的 roomName 后加入房间，等待其他人匹配加入。

这个流程在客户端中的示例代码如下（非 Client Engine）：

客户端首先向多人对战服务发起有条件的加入房间请求：

const matchProps = {level: 2};
play.joinRandomRoom({matchProperties: matchProps});

如果多人对战服务此时有可以加入的新房间，您会自动加入到新房间中，并触发加入房间成功事件：

play.on(Event.ROOM_JOINED, () => {
    // TODO 可以做跳转场景之类的操作
});

如果没有可以加入的房间，会触发加入房间失败事件。在这个事件中，4301 错误码代表着没有可以加入的空房间，此时我们向 Client Engine 请求创建一个新的房间，获得新房间的 roomName 后加入新房间：

// 加入房间失败后请求 Client Engine 创建房间
play.on(Event.ROOM_JOIN_FAILED, (error) => {
  if (error.code === 4301) {
    // 设置创建带有匹配属性的房间
    const props = {level: 2};
    const options = {customRoomPropertyKeysForLobby: ['level']};
    // 这里通过 HTTP 调用在 Client Engine 中实现的 `/game` 接口
    const { roomName } = await (await fetch(
      `${CLIENT_ENGINE_SERVER}/game`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          playerId: play.userId,
          options
        })
      }
    )).json();
    // 加入房间
    return play.joinRoom(roomName);
  } else {
    console.log(error);
  }
});

Game

Game 生命周期

  1. 创建： Game 由 SDK 中的 GameManager 管理，GameManager 会在收到创建房间的请求时根据情况创建 Game。
  2. 运行： 创建后，Game 的控制权从 SDK 中 GameManager 移交给 Game 本身。从这个时刻开始，会有玩家陆续加入游戏房间。
  3. 销毁： 所有玩家离开房间后，意味着游戏结束，Game 将控制权交回 GameManager，GameManager 做最后的清理工作，包括断开并销毁该房间的 masterClient、将 Game 从管理的游戏列表中删除等。

Game 通用属性

在实现游戏逻辑的过程中，Game 类提供下面这些属性来简化常见需求的实现，您可以在继承 Game 的自己的类中方便的获得以下属性：

  • room 属性：游戏对应的房间，这是一个 Play SDK 中的 Room 实例。
  • masterClient 属性：游戏对应的 masterClient，这是一个 Play SDK 中的 Play 实例。
  • players 属性：不包含 masterClient 的玩家列表。注意，如果您通过 Play SDK Room 实例的 playerList 属性获取的房间成员列表是包括 masterClient 的。

Game 通用方法

Game 类在多人对战 SDK 的基础上封装了以下方法，使得 MasterClient 可以更便利的发送自定义事件：

  • broadcast() 方法：向所有玩家广播自定义事件。示例代码请参考广播自定义事件。
  • forwardToTheRests() 方法：将一个玩家发送的自定义事件转发给其他玩家。示例代码请参考转发自定义事件。

实现自己的 Game

实现自己的房间内游戏逻辑时，您需要创建一个继承自 Game 的类来撰写自己的游戏逻辑，示例方法如下：

import { Game } from "@leancloud/client-engine";
export default class SampleGame extends Game {
  constructor(room: Room, masterClient: Play) {
    super(room, masterClient);
  }
}

设置房间内玩家数量

这里的玩家数量指的是不包括 MasterClient 的玩家数量，根据多人对战服务的限制，最多不能超过 9 个人。

在 Game 中需要指定 defaultSeatCount 静态属性作为默认的玩家数量，Client Engine 会根据这个值向多人对战服务请求创建房间。例如斗地主需要 3 个人才能玩，可以这样设置：

export default class SampleGame extends Game {
  public static defaultSeatCount = 3; // 最大不能超过 9
}

如果您的游戏需要的玩家数量在某个范围内，除了设置 defaultSeatCount 外，还需要使用 minSeatCount 静态属性限定最小玩家数量，maxSeatCount 静态属性设定最大玩家数量。例如三国杀要求至少 2 个人，最多 8 个人才能玩，默认 5 个人可以玩，可以这样设置：

export default class SampleGame extends Game {
  public static minSeatCount = 2;
  public static maxSeatCount = 8; // 最大不能超过 9
  public static defaultSeatCount = 5;
}

在创建房间的接口中，可以将客户端 request 请求中的 seatCount 参数来动态覆盖掉 defaultSeatCount。

当房间人数达到 seatCount 时，您可以选择配置触发房间人满事件，如果您的客户端没有指定 seatCount，人满事件时将以 defaultSeatCount 的值为准。

加入房间事件

当客户端成功加入房间后，位于 Client Engine 的 MasterClient 会收到新玩家加入事件，如果您需要监听此事件，可以在自定义的 Game 中的 constructor() 方法中撰写监听的代码：

import { Game } from "@leancloud/client-engine";
export default class SampleGame extends Game {
  constructor(room: Room, masterClient: Play) {
    super(room, masterClient);
    this.masterClient.on(Event.PLAYER_ROOM_JOINED, () => {
      console.log('有人来了');
    });
  }
}

房间人满事件

当房间的人数满足设置房间内玩家数量的人满逻辑时，watchRoomFull 装饰器会让您收到 Game 抛出的 AutomaticGameEvent.ROOM_FULL 事件，您可以在这个事件中撰写相应的游戏逻辑，例如关闭房间，向客户端广播游戏开始：

import { AutomaticGameEvent, Game, watchRoomFull } from "@leancloud/client-engine";

enum Event {
  GameStart = 15,
};

@watchRoomFull()
export default class SampleGame extends Game {
  constructor(room: Room, masterClient: Play) {
    super(room, masterClient);
    // 监听 ROOM_FULL 事件，收到此事件后调用 `start() 方法`
    this.once(AutomaticGameEvent.ROOM_FULL, this.start);
  }

  protected start = async () => {
    // 在这里撰写自己房间人满后的逻辑
    // 标记房间不再可加入
    this.masterClient.setRoomOpened(false);
    // 向客户端广播游戏开始事件
    this.broadcast(Event.GameStart);
  }
}

广播自定义事件

在房间人满事件中，Game 向房间内所有成员广播了游戏开始：

enum Event {
  GameStart = 15,
};
this.broadcast(Event.GameStart);

在广播事件时您还可以带有一些数据：

enum Event {
  GameStart = 15,
};
const gameData = {someGameData};
this.broadcast(Event.GameStart, gameData);

此时客户端的接收自定义事件方法会被触发，如果发现是 game-start 事件，客户端可以在 UI 上展示对战开始。

转发自定义事件

MasterClient 可以转发某个客户端发来的事件给其他客户端，在转发时还可以处理数据：

enum Event {
  SomeEvent = 15,
};
this.forwardToTheRests(event, (eventData) => {
  // 准备要转发的数据
  const actUserId = event.senderId;
  const result = {actUserId};
  return result;
  // Event.SomeEvent 是自定义事件的 ID，如果省略则使用原 event 事件的 ID
}, Event.SomeEvent)

在这个代码中，event 参数是某个客户端发来的原始事件，eventData 是原始事件的数据，您可以在转发事件给其他客户端时处理该数据，例如抹去或增加一些信息。MasterClient 发送该事件后，客户端的接收自定义事件会被触发。

MasterClient 与客户端通信

除了上方初始项目提供的广播自定义事件及转发自定义事件外，您依然可以使用多人对战服务中的自定义属性、自定义事件进行通信。

除此之外，Game 还提供了以下 RxJS 方法方便您对事件进行流处理，进而精简自己的代码及逻辑：

  • getStream() 方法：获取玩家发送的自定义事件的流，这是一个 RxJS 中的 Observable 对象。接口说明请参考 API 文档。
  • takeFirst() 方法：获取玩家发送的指定条件的从现在开始算的第一条自定义事件的流，返回一个 RxJS 中的 Observable 对象。接口说明请参考 API 文档。

注意，以上两个方法需要您了解 RxJS 才能使用，如果您不了解 RxJS，依然可以使用多人对战服务中的事件方法进行通信。

游戏结束

当所有玩家都离开后，GameManager 会自动帮您销毁当前房间及相关的 MasterClient。此时如果您没有其他的逻辑要做，则不需要关心本节文档。如果您希望自己做一些清理工作，例如保存用户数据等，可以使用 autoDestroy 装饰器，这个装饰器会在所有玩家离开后自动触发 Game 子类中的 destroy() 方法，您可以将相关逻辑写在这个方法中。

import { autoDestroy, Game } from "@leancloud/client-engine";

@autoDestroy()
export default class SampleGame extends Game {
  protected destroy() {
    super.destroy();
    console.log('在这里可以做额外的清理工作');
  }
}

负载均衡

Client Engine 会根据整体实例负载的高低自动对实例数量进行调整。

在 Client Engine 中，需要负载均衡的情况有两种：第一种是客户端通过 REST API 发起的请求，第二种是每一个实例运行的 Game 数量的负载。对于客户端通过 REST API 发起的请求，Client Engine 会自动将请求均匀的分配给当前的所有实例，不需要我们再做任何配置工作。对于第二种情况，每个 Game 对象（每局游戏）一般都会持续存在一段时间，为了让每个实例承载的 Game 对象尽可能达到均衡，我们需要额外配置 GameManager 到负载均衡系统中。

这个特性由 SDK 提供的 LoadBalancerFactory 类实现。在 GameManager 实例化中我们可以看到，LoadBalancerFactory 通过绑定 gameManager 生成一个 LoadBalancer 的对象，每一个 Client Engine 实例中都会有这样一个对象。

当 Client Engine 的某个实例接收到来自客户端的 REST API 请求，并调用 gameManager 中的方法时，接收请求的实例中的负载均衡节点 LoadBalancer 会找出集群中承载 Game 数量最小的实例，将指定的 gameManager 的 API 调用转发给该实例的 gameManager 运行并将结果返回。在这里，LoadBalancer 只负责请求的转发，不关心如何处理请求。

API 文档

您可以在 API 文档中找到更多 SDK 的类、方法及属性说明，点击查看 Client Engine SDK API 文档。

{{allComment[version]}} ×
  • 暂无评论
  • {{comment.author}}
    {{ comment.createdAt | date: 'yyyy-MM-dd HH:mm:ss '}}
    {{comment.content}}
您需要 后才能评论