房间管理
核心流程

概念说明
- 房间: 玩家联机的虚拟空间,每个房间有唯一的房间 ID
- 房主: 创建房间的玩家,拥有特殊权限(踢人、修改房间属性)
- 监听回调:当有玩家进入或离开房间时,SDK 会通过回调通知其他玩家
房间信息
当通过不同方式进入房间后,SDK 会返回房间内具体信息,包括房间属性和房间内所有玩家属性,具体参数如下:
| 参数名 | 类型 | 说明 |
|---|---|---|
| id | string | 房间 ID |
| name | string | 房间名称,如果创建或更新时未设置,默认为空字符串 |
| type | string | 房间类型 |
| ownerId | string | 房主 ID ,当原房主离开房间且房间内有其他玩家时,该值会变更为房间内其他玩家 |
| status | int | 0-未开始帧同步,1-帧同步中 |
| customProperties | string | 自定义房间属性 |
| maxPlayerCount | int | 房间最大支持人数 |
| players | List | 房间内玩家信息集合 |
| createTime | string | 房间创建时间,1970 年开始的秒数 |
其中玩家信息如下:
| 参数名 | 类型 | 说明 |
|---|---|---|
| id | string | 玩家 ID |
| status | int | 玩家状态:0-离线、1-在线 |
| customStatus | int | 自定义玩家状态,开发者可随意设置任何值,意义由开发者自行判断 |
| customProperties | string | 自定义玩家属性,开发者可以随意设置任何数据,最大为 2048 字节 |
进入房间
进入房间有三种不同的方式,创建房间、匹配房间以及获取房间列表后加入指定房间等,通过创建房间加入时会自动成为房主。
创建房间
在创建和匹配房间时,需要设置房间配置(必选)和玩家配置(可选),具体参数如下:
房间配置
| 参数名 | 类型 | 说明 | 是否必选 |
|---|---|---|---|
| maxPlayerCount | int | 房间最大支持人数,取值范围为 1 ~ 20 | 是 |
| type | string | 房间类型,最大 32 字节 | 是 |
| name | string | 房间名称,最大 64 字节,当匹配房间时,无需设置该参数 | 否 |
| customProperties | string | 自定义房间属性,最大 2048 字节 | 否 |
| matchParams | Dictionary | 房间匹配参数,最大支持 3 个 K/V 对, K/V 取值由开发者决定,K 最大 32 字节,V 最大 64 字节 | 否 |
玩家配置
| 参数名 | 类型 | 说明 | 是否必选 |
|---|---|---|---|
| customStatus | int | 自定义玩家状态,开发者可随意设置任何值,意义由开发者自行判断 | 否 |
| customProperties | string | 自定义玩家属性,开发者可以随意设置任何数据,最大为 2048 字节 | 否 |
请求成功后,会返回对应房间的具体信息,示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
// 定义匹配参数
Dictionary<string, string> matchParams = null;
// 定义房间配置
var config = new CreateRoomConfig()
{
// 房间配置
roomConfig = new RoomConfig()
{
maxPlayerCount = roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType, // 房间类型,最大32字节,必填
name = roomName, // 房间名称,最大64个字节,选填
customProperties = roomProperty, // 自定义房间属性,最大2048字节,选填
matchParams = matchParams, // 房间匹配参数,选填,最大支持3个K/V对, K/V取值由开发者决定,K最大32字节,V最大64字节
},
// 玩家配置
playerConfig = new PlayerConfig()
{
customStatus = playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties = playerProperty, // 自定义玩家属性,选填
},
};
try
{
RoomInfo data = await TapTapOnlineBattle.CreateRoom(config);
LogMessage(" 创建房间成功 " + JsonConvert.SerializeObject(data));
}
catch (TapException e)
{
LogMessage($"创建房间 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.CreateRoomListener;
import com.taptap.sdk.battle.model.CreateRoomConfig;
import com.taptap.sdk.battle.model.RoomConfig;
import com.taptap.sdk.battle.model.PlayerConfig;
import com.taptap.sdk.battle.model.RoomInfo;
import com.taptap.sdk.kit.internal.exception.TapError;
// 定义匹配参数
Map<String, String> matchParams = null;
// 定义房间配置
RoomConfig roomConfig = new RoomConfig();
roomConfig.setMaxPlayerCount(roomMaxPlayerCount); // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.setType(roomType); // 房间类型,最大32字节,必填
roomConfig.setName(roomName); // 房间名称,最大64个字节,选填
roomConfig.setCustomProperties(roomProperty); // 自定义房间属性,最大2048字节,选填
roomConfig.setMatchParams(matchParams); // 房间匹配参数,选填
// 定义玩家配置
PlayerConfig playerConfig = new PlayerConfig();
playerConfig.setCustomStatus(playerCustomStatus); // 自定义玩家状态,整型,选填
playerConfig.setCustomProperties(playerProperty); // 自定义玩家属性,选填
// 创建房间配置
CreateRoomConfig config = new CreateRoomConfig(roomConfig, playerConfig);
TapTapBattle.createRoom(config, new CreateRoomListener() {
@Override
public void onSuccess(RoomInfo roomInfo) {
Log.d("Battle", "创建房间成功 " + roomInfo.toString());
}
@Override
public void onError(TapError error) {
Log.e("Battle", "创建房间 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.CreateRoomListener
import com.taptap.sdk.battle.model.CreateRoomConfig
import com.taptap.sdk.battle.model.RoomConfig
import com.taptap.sdk.battle.model.PlayerConfig
import com.taptap.sdk.battle.model.RoomInfo
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
// 定义匹配参数
val matchParams: Map<String, String>? = null
// 定义房间配置
val roomConfig = RoomConfig().apply {
maxPlayerCount = roomMaxPlayerCount // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType // 房间类型,最大32字节,必填
name = roomName // 房间名称,最大64个字节,选填
customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
this.matchParams = matchParams // 房间匹配参数,选填
}
// 定义玩家配置
val playerConfig = PlayerConfig().apply {
customStatus = playerCustomStatus // 自定义玩家状态,整型,选填
customProperties = playerProperty // 自定义玩家属性,选填
}
// 创建房间配置
val config = CreateRoomConfig(roomConfig, playerConfig)
TapTapBattle.createRoom(config, object : CreateRoomListener {
override fun onSuccess(roomInfo: RoomInfo) {
Log.d("Battle", "创建房间成功 $roomInfo")
}
override fun onError(error: TapError) {
Log.e("Battle", "创建房间 error ${error.code} ${error.message}")
}
})
import TapTapSDK
// 定义匹配参数
let matchParams: [String: String]? = nil
// 定义房间配置
let roomConfig = RoomConfig()
roomConfig.maxPlayerCount = roomMaxPlayerCount // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.type = roomType // 房间类型,最大32字节,必填
roomConfig.name = roomName // 房间名称,最大64个字节,选填
roomConfig.customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
roomConfig.matchParams = matchParams // 房间匹配参数,选填
// 定义玩家配置
let playerConfig = PlayerConfig()
playerConfig.customStatus = playerCustomStatus // 自定义玩家状态,整型,选填
playerConfig.customProperties = playerProperty // 自定义玩家属性,选填
// 创建房间请求
let request = CreateRoomRequest(roomCfg: roomConfig, playerCfg: playerConfig)
TapTapBattle.createRoom(request: request) { roomInfo, error in
if let error = error {
print("创建房间 error \(error.code) \(error.message)")
} else if let roomInfo = roomInfo {
print("创建房间成功 \(roomInfo)")
}
}
#import <TapTapSDK/TapTapSDK.h>
// 定义匹配参数
NSDictionary<NSString *, NSString *> *matchParams = nil;
// 定义房间配置
RoomConfig *roomConfig = [[RoomConfig alloc] init];
roomConfig.maxPlayerCount = roomMaxPlayerCount; // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.type = roomType; // 房间类型,最大32字节,必填
roomConfig.name = roomName; // 房间名称,最大64个字节,选填
roomConfig.customProperties = roomProperty; // 自定义房间属性,最大2048字节,选填
roomConfig.matchParams = matchParams; // 房间匹配参数,选填
// 定义玩家配置
PlayerConfig *playerConfig = [[PlayerConfig alloc] init];
playerConfig.customStatus = playerCustomStatus; // 自定义玩家状态,整型,选填
playerConfig.customProperties = playerProperty; // 自定义玩家属性,选填
// 创建房间请求
CreateRoomRequest *request = [[CreateRoomRequest alloc] initWithRoomCfg:roomConfig playerCfg:playerConfig];
[TapTapBattle createRoomWithRequest:request callback:^(RoomInfo *roomInfo, NSError *error) {
if (error) {
NSLog(@"创建房间 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"创建房间成功 %@", roomInfo);
}
}];
匹配房间
匹配房间时使用的配置参数和创建房间一致,当没有满足条件的房间存在时,会自动创建一个新房间, 匹配成功后返回对应的房间信息。
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
// 定义匹配参数
Dictionary<string, string> matchParams = null;
// 定 义房间配置
var config = new MatchRoomConfig()
{
// 房间配置
roomConfig = new RoomConfig()
{
maxPlayerCount = roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType, // 房间类型,最大32字节,必填
customProperties = roomProperty, // 自定义房间属性,最大2048字节,选填
matchParams = matchParams, // 房间匹配参数,选填,最大支持3个K/V对, K/V取值由开发者决定,K最大32字节,V最大64字节
},
// 玩家配置
playerConfig = new PlayerConfig()
{
customStatus = playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties = playerProperty, // 自定义玩家属性,选填
},
};
try
{
RoomInfo data = await TapTapOnlineBattle.MatchRoom(config);
LogMessage(" 匹配房间成功 " + JsonConvert.SerializeObject(data));
// 如果此时是加入已存在的房间,房间内其他玩家会通过 OnPlayerEntered 回调收到通知
}
catch (TapException e)
{
LogMessage($"匹配房间 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.MatchRoomListener;
import com.taptap.sdk.battle.model.MatchRoomConfig;
import com.taptap.sdk.battle.model.RoomConfig;
import com.taptap.sdk.battle.model.PlayerConfig;
import com.taptap.sdk.battle.model.RoomInfo;
import com.taptap.sdk.kit.internal.exception.TapError;
// 定义匹配参数
Map<String, String> matchParams = null;
// 定义房间配置
RoomConfig roomConfig = new RoomConfig();
roomConfig.setMaxPlayerCount(roomMaxPlayerCount); // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.setType(roomType); // 房间类型,最大32字节,必填
roomConfig.setCustomProperties(roomProperty); // 自定义房间属性,最大2048字节,选填
roomConfig.setMatchParams(matchParams); // 房间匹配参数,选填
// 定义玩家配置
PlayerConfig playerConfig = new PlayerConfig();
playerConfig.setCustomStatus(playerCustomStatus); // 自定义玩家状态,整型,选填
playerConfig.setCustomProperties(playerProperty); // 自定义玩家属性,选填
// 匹配房间配置
MatchRoomConfig config = new MatchRoomConfig(roomConfig, playerConfig);
TapTapBattle.matchRoom(config, new MatchRoomListener() {
@Override
public void onSuccess(RoomInfo roomInfo) {
Log.d("Battle", "匹配房间成功 " + roomInfo.toString());
// 如果此时是加入已存在的房间,房间内其他玩家会通过 OnPlayerEntered 回调收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "匹配房间 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.MatchRoomListener
import com.taptap.sdk.battle.model.MatchRoomConfig
import com.taptap.sdk.battle.model.RoomConfig
import com.taptap.sdk.battle.model.PlayerConfig
import com.taptap.sdk.battle.model.RoomInfo
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
// 定义匹配参数
val matchParams: Map<String, String>? = null
// 定义房间配置
val roomConfig = RoomConfig().apply {
maxPlayerCount = roomMaxPlayerCount // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType // 房间类型,最大32字节,必填
customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
this.matchParams = matchParams // 房间匹配参数,选填
}
// 定义玩家配置
val playerConfig = PlayerConfig().apply {
customStatus = playerCustomStatus // 自定义玩家状态,整型,选填
customProperties = playerProperty // 自定义玩家属性,选填
}
// 匹配房间配置
val config = MatchRoomConfig(roomConfig, playerConfig)
TapTapBattle.matchRoom(config, object : MatchRoomListener {
override fun onSuccess(roomInfo: RoomInfo) {
Log.d("Battle", "匹配房间成功 $roomInfo")
// 如果此时是加入已存在的房间,房间内其他玩家会通过 OnPlayerEntered 回调收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "匹配房间 error ${error.code} ${error.message}")
}
})
import TapTapSDK
// 定义匹配参数
let matchParams: [String: String]? = nil
// 定义房间配置
let roomConfig = RoomConfig()
roomConfig.maxPlayerCount = roomMaxPlayerCount // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.type = roomType // 房间类型,最大32字节,必填
roomConfig.customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
roomConfig.matchParams = matchParams // 房间匹配参数,选填
// 定义玩家配置
let playerConfig = PlayerConfig()
playerConfig.customStatus = playerCustomStatus // 自定义玩家状态,整型,选填
playerConfig.customProperties = playerProperty // 自定义玩家属性,选填
// 匹配房间请求
let request = MatchRoomRequest(roomCfg: roomConfig, playerCfg: playerConfig)
TapTapBattle.matchRoom(request: request) { roomInfo, error in
if let error = error {
print("匹配房间 error \(error.code) \(error.message)")
} else if let roomInfo = roomInfo {
print("匹配房间成功 \(roomInfo)")
// 如果此时是加入已存在的房间,房间内其他玩家会通过 OnPlayerEntered 回调收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
// 定义匹配参数
NSDictionary<NSString *, NSString *> *matchParams = nil;
// 定义房间配置
RoomConfig *roomConfig = [[RoomConfig alloc] init];
roomConfig.maxPlayerCount = roomMaxPlayerCount; // 房间最大支持人数,取值范围为[1, 20],必填
roomConfig.type = roomType; // 房间类型,最大32字节,必填
roomConfig.customProperties = roomProperty; // 自定义房间属性,最大2048字节,选填
roomConfig.matchParams = matchParams; // 房间匹配参数,选填
// 定义玩家配置
PlayerConfig *playerConfig = [[PlayerConfig alloc] init];
playerConfig.customStatus = playerCustomStatus; // 自定义玩家状态,整型,选填
playerConfig.customProperties = playerProperty; // 自定义玩家属性,选填
// 匹配房间请求
MatchRoomRequest *request = [[MatchRoomRequest alloc] initWithRoomCfg:roomConfig playerCfg:playerConfig];
[TapTapBattle matchRoomWithRequest:request callback:^(RoomInfo *roomInfo, NSError *error) {
if (error) {
NSLog(@"匹配房间 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"匹配房间成功 %@", roomInfo);
// 如果此时是加入已存在的房间,房间内其他玩家会通过 OnPlayerEntered 回调收到通知
}
}];
如果此时是加入已存在的房间,房间内其他玩家会通过 SDK 的 OnPlayerEntered 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家进入房间
/// </summary>
/// <param name="roomId"> 房间ID </param>
/// <param name="playerInfo"> 玩家信息 </param>
public void OnPlayerEntered(string roomId, TapSDK.OnlineBattle.PlayerInfo playerInfo)
{
LogMessage(
$"receive OnPlayerEntered {roomId}:{JsonConvert.SerializeObject(playerInfo)}"
);
}
// 玩家进入房间
@Override
public void onPlayerEntered(String roomId, PlayerInfo playerInfo) {
Log.d("Battle", "receive OnPlayerEntered " + roomId + ":" + playerInfo.toString());
}
// 玩家进入房间
override fun onPlayerEntered(roomId: String, playerInfo: PlayerInfo) {
Log.d("Battle", "receive OnPlayerEntered $roomId:$playerInfo")
}
// 玩家进入房间
func onPlayerEntered(roomId: String, playerInfo: PlayerInfo) {
print("receive OnPlayerEntered \(roomId):\(playerInfo)")
}
// 玩家进入房间
- (void)onPlayerEntered:(NSString *)roomId playerInfo:(PlayerInfo *)playerInfo {
NSLog(@"receive OnPlayerEntered %@:%@", roomId, playerInfo);
}
获取房间列表
开发者可通过具体房间类型获取对应房间列表数据,示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
RoomListData data = await TapTapOnlineBattle.GetRoomList(
roomType, // 房间类型
offset, // 请求偏移量,默认为 0
limit // 请求获取的房间数量,默认为 20
);
LogMessage(" 查询房间列表成功 " + JsonConvert.SerializeObject(data));
}
catch (TapException e)
{
LogMessage($"查询房间列表 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.GetRoomListListener;
import com.taptap.sdk.battle.model.GetRoomListRequest;
import com.taptap.sdk.battle.model.RoomListData;
import com.taptap.sdk.kit.internal.exception.TapError;
GetRoomListRequest request = new GetRoomListRequest();
request.setType(roomType); // 房间类型
request.setOffset(offset); // 请求偏移量,默认为 0
request.setLimit(limit); // 请求获取的房间数量,默认为 20
TapTapBattle.getRoomList(request, new GetRoomListListener() {
@Override
public void onSuccess(RoomListData data) {
Log.d("Battle", "查询房间列表成功 " + data.toString());
}
@Override
public void onError(TapError error) {
Log.e("Battle", "查询房间列表 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.GetRoomListListener
import com.taptap.sdk.battle.model.GetRoomListRequest
import com.taptap.sdk.battle.model.RoomListData
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
val request = GetRoomListRequest().apply {
type = roomType // 房间类型
offset = this@YourClass.offset // 请求偏移量,默认为 0
limit = this@YourClass.limit // 请求获取的房间数量,默认为 20
}
TapTapBattle.getRoomList(request, object : GetRoomListListener {
override fun onSuccess(data: RoomListData) {
Log.d("Battle", "查询房间列表成功 $data")
}
override fun onError(error: TapError) {
Log.e("Battle", "查询房间列表 error ${error.code} ${error.message}")
}
})
import TapTapSDK
let request = GetRoomListRequest()
request.type = roomType // 房间类型
request.offset = offset // 请求偏移量,默认为 0
request.limit = limit // 请求获取的房间数量,默认为 20
TapTapBattle.getRoomList(request) { data, error in
if let error = error {
print("查询房间列表 error \(error.code) \(error.message)")
} else if let data = data {
print("查询房间列表成功 \(data)")
}
}
#import <TapTapSDK/TapTapSDK.h>
GetRoomListRequest *request = [[GetRoomListRequest alloc] init];
request.type = roomType; // 房间类型
request.offset = offset; // 请求偏移量,默认为 0
request.limit = limit; // 请求获取的房间数量,默认为 20
[TapTapBattle getRoomList:request callback:^(RoomListData *data, NSError *error) {
if (error) {
NSLog(@"查询房间列表 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"查询房间列表成功 %@", data);
}
}];
首次请求时,请求参数中 offset 传 0 即可。拉取下一页房间列表时,请传递上一次请求结果中的 offset 字段的值。
返回结果 RoomListData 包含三个字段 :
offset:用于请求下一页房间列表的offset值hasMore:表示是否还有更多房间,true 表示有更多房间,false 表示没有rooms: 房间列表数据,包含对应类型房间的信息集合
rooms 中各房间信息字段如下:
| 参数名 | 类型 | 说明 |
|---|---|---|
| id | string | 房间 ID |
| name | string | 房间名称,如果创建或更新时未设置,默认为空字符串 |
| type | string | 房间类型 |
| status | int | 0-未开始帧同步,1-帧同步中 |
| customProperties | string | 自定义房间属性 |
| maxPlayerCount | int | 房间最大支持人数 |
| createTime | string | 房间创建时间,1970 年开始的秒数 |
加入房间
使用目标房间的房间 ID 可加入对应房间,成功后,会返回包含所有玩家的具体房间信息。示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
// 玩家配置
var playerConfig = new PlayerConfig()
{
customStatus = joinPlayerStatus, // 自定义玩家状态,整形,选填。开发者可随意设置任何值,意义由开发者自行判断
customProperties = joinPlayerProperty, // 自定义玩家属性,选填。开发者可以随意设置任何数据,最大长度为2048字节
};
try
{
RoomInfo data = await TapTapOnlineBattle.JoinRoom(
joinRoomId, // 房间ID
playerConfig // 玩家配置,选填
);
LogMessage(" 加入房间成功 " + JsonConvert.SerializeObject(data));
// 其他玩家会通过 OnPlayerEntered 回调收到通知
}
catch (TapException e)
{
LogMessage($"加入房间 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.JoinRoomListener;
import com.taptap.sdk.battle.model.JoinRoomRequest;
import com.taptap.sdk.battle.model.PlayerConfig;
import com.taptap.sdk.battle.model.RoomInfo;
import com.taptap.sdk.kit.internal.exception.TapError;
// 玩家配置
PlayerConfig playerConfig = new PlayerConfig();
playerConfig.setCustomStatus(joinPlayerStatus); // 自定义玩家状态,整形,选填
playerConfig.setCustomProperties(joinPlayerProperty); // 自定义玩家属性,选填
JoinRoomRequest request = new JoinRoomRequest();
request.setRoomId(joinRoomId); // 房间ID
request.setPlayerConfig(playerConfig); // 玩家配置,选填
TapTapBattle.joinRoom(request, new JoinRoomListener() {
@Override
public void onSuccess(RoomInfo data) {
Log.d("Battle", "加入房间成功 " + data.toString());
// 其他玩家会通过 OnPlayerEntered 回调收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "加入房间 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.JoinRoomListener
import com.taptap.sdk.battle.model.JoinRoomRequest
import com.taptap.sdk.battle.model.PlayerConfig
import com.taptap.sdk.battle.model.RoomInfo
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
// 玩家配置
val playerConfig = PlayerConfig().apply {
customStatus = joinPlayerStatus // 自定义玩家状态,整形,选填
customProperties = joinPlayerProperty // 自定义玩家属性,选填
}
val request = JoinRoomRequest().apply {
roomId = joinRoomId // 房间ID
this.playerConfig = playerConfig // 玩家配置,选填
}
TapTapBattle.joinRoom(request, object : JoinRoomListener {
override fun onSuccess(data: RoomInfo) {
Log.d("Battle", "加入房间成功 $data")
// 其他玩家会通过 OnPlayerEntered 回调收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "加入房间 error ${error.code} ${error.message}")
}
})
import TapTapSDK
// 玩家配置
let playerConfig = PlayerConfig()
playerConfig.customStatus = joinPlayerStatus // 自定义玩家状态,整形,选填
playerConfig.customProperties = joinPlayerProperty // 自定义玩家属性,选填
let request = JoinRoomRequest()
request.roomId = joinRoomId // 房间ID
request.playerConfig = playerConfig // 玩家配置,选填
TapTapBattle.joinRoom(request) { data, error in
if let error = error {
print("加入房间 error \(error.code) \(error.message)")
} else if let data = data {
print("加入房间成功 \(data)")
// 其他玩家会通过 OnPlayerEntered 回调收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
// 玩家配置
PlayerConfig *playerConfig = [[PlayerConfig alloc] init];
playerConfig.customStatus = joinPlayerStatus; // 自定义玩家状态,整形,选填
playerConfig.customProperties = joinPlayerProperty; // 自定义玩家属性,选填
JoinRoomRequest *request = [[JoinRoomRequest alloc] init];
request.roomId = joinRoomId; // 房间ID
request.playerConfig = playerConfig; // 玩家配置,选填
[TapTapBattle joinRoom:request callback:^(RoomInfo *data, NSError *error) {
if (error) {
NSLog(@"加入房间 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"加入房间成功 %@", data);
// 其他玩家会通过 OnPlayerEntered 回调收到通知
}
}];
加入成功后其他玩家也会通过 OnPlayerEntered 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家进入房间
/// </summary>
/// <param name="roomId"> 房间ID </param>
/// <param name="playerInfo"> 玩家信息 </param>
public void OnPlayerEntered(string roomId, TapSDK.OnlineBattle.PlayerInfo playerInfo)
{
LogMessage(
$"receive OnPlayerEntered {roomId}:{JsonConvert.SerializeObject(playerInfo)}"
);
}
// 玩家进入房间
@Override
public void onPlayerEntered(String roomId, PlayerInfo playerInfo) {
Log.d("Battle", "receive OnPlayerEntered " + roomId + ":" + playerInfo.toString());
}
// 玩家进入房间
override fun onPlayerEntered(roomId: String, playerInfo: PlayerInfo) {
Log.d("Battle", "receive OnPlayerEntered $roomId:$playerInfo")
}
// 玩家进入房间
func onPlayerEntered(roomId: String, playerInfo: PlayerInfo) {
print("receive OnPlayerEntered \(roomId):\(playerInfo)")
}
// 玩家进入房间
- (void)onPlayerEntered:(NSString *)roomId playerInfo:(PlayerInfo *)playerInfo {
NSLog(@"receive OnPlayerEntered %@:%@", roomId, playerInfo);
}
管理房间
更新房间信息
只有房主可更新当前房间信息,包含名称和自定义属性等,示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
await TapTapOnlineBattle.UpdateRoomProperties(
updateRoomName, // 房间名称
updateRoomProperty // 房间自定义属性,最大支持 2048 字节
);
LogMessage(" 更新房间属性 成功 ");
// 所有玩家会通过 OnRoomPropertiesChanged 回调收到通知
}
catch (TapException e)
{
LogMessage($"更新房间属性 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.UpdateRoomPropertiesListener;
import com.taptap.sdk.battle.model.UpdateRoomPropertiesRequest;
import com.taptap.sdk.kit.internal.exception.TapError;
UpdateRoomPropertiesRequest request = new UpdateRoomPropertiesRequest();
request.setName(updateRoomName); // 房间名称
request.setCustomProperties(updateRoomProperty); // 房间自定义属性,最大支持 2048 字节
TapTapBattle.updateRoomProperties(request, new UpdateRoomPropertiesListener() {
@Override
public void onSuccess(Void result) {
Log.d("Battle", "更新房间属性 成功");
// 所有玩家会通过 OnRoomPropertiesChanged 回调收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "更新房间属性 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.UpdateRoomPropertiesListener
import com.taptap.sdk.battle.model.UpdateRoomPropertiesRequest
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
val request = UpdateRoomPropertiesRequest().apply {
name = updateRoomName // 房间名称
customProperties = updateRoomProperty // 房间自定义属性,最大支持 2048 字节
}
TapTapBattle.updateRoomProperties(request, object : UpdateRoomPropertiesListener {
override fun onSuccess(result: Void?) {
Log.d("Battle", "更新房间属性 成功")
// 所有玩家会通过 OnRoomPropertiesChanged 回调收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "更新房间属性 error ${error.code} ${error.message}")
}
})
import TapTapSDK
let request = UpdateRoomPropertiesRequest()
request.name = updateRoomName // 房间名称
request.customProperties = updateRoomProperty // 房间自定义属性,最大支持 2048 字节
TapTapBattle.updateRoomProperties(request) { error in
if let error = error {
print("更新房间属性 error \(error.code) \(error.message)")
} else {
print("更新房间属性 成功")
// 所有玩家会通过 OnRoomPropertiesChanged 回调收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
UpdateRoomPropertiesRequest *request = [[UpdateRoomPropertiesRequest alloc] init];
request.name = updateRoomName; // 房间名称
request.customProperties = updateRoomProperty; // 房间自定义属性,最大支持 2048 字节
[TapTapBattle updateRoomProperties:request callback:^(NSError *error) {
if (error) {
NSLog(@"更新房间属性 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"更新房间属性 成功");
// 所有玩家会通过 OnRoomPropertiesChanged 回调收到通知
}
}];
更新成功后所有玩家会通过 SDK 的 OnRoomPropertiesChanged 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 房间属性变更
/// </summary>
/// <param name="id"> 房间 ID </param>
/// <param name="name"> 房间名称 </param>
/// <param name="customProperties"> 房间自定义属性 </param>
public void OnRoomPropertiesChanged(string id, string name, string customProperties)
{
LogMessage($"receive OnRoomPropertiesChanged {id}:{name}:{customProperties}");
}
// 房间属性变更
@Override
public void onRoomPropertiesChanged(String id, String name, String customProperties) {
Log.d("Battle", "receive OnRoomPropertiesChanged " + id + ":" + name + ":" + customProperties);
}
// 房间属性变更
override fun onRoomPropertiesChanged(id: String, name: String, customProperties: String) {
Log.d("Battle", "receive OnRoomPropertiesChanged $id:$name:$customProperties")
}
// 房间属性变更
func onRoomPropertiesChanged(id: String, name: String, customProperties: String) {
print("receive OnRoomPropertiesChanged \(id):\(name):\(customProperties)")
}
// 房间属性变更
- (void)onRoomPropertiesChanged:(NSString *)id name:(NSString *)name customProperties:(NSString *)customProperties {
NSLog(@"receive OnRoomPropertiesChanged %@:%@:%@", id, name, customProperties);
}
更新玩家自定义状态
每个玩家均可更新自身的当前自定义状态,用于标识玩家在房间或对战过程中的关键状态,例如未就绪、已就绪等,示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
await TapTapOnlineBattle.UpdatePlayerCustomStatus(updatePlayerStatus);
LogMessage(" 更新玩家状态 成功 ");
// 房间内玩家会通过 OnPlayerCustomStatusChanged 回调收到通知
}
catch (TapException e)
{
LogMessage($"更新玩家状态 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.UpdatePlayerCustomStatusListener;
import com.taptap.sdk.kit.internal.exception.TapError;
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapBattle.updatePlayerCustomStatus(updatePlayerStatus, new UpdatePlayerCustomStatusListener() {
@Override
public void onSuccess(Void result) {
Log.d("Battle", "更新玩家状态 成功");
// 房间内玩家会通过 OnPlayerCustomStatusChanged 回调收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "更新玩家状态 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.UpdatePlayerCustomStatusListener
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapBattle.updatePlayerCustomStatus(updatePlayerStatus, object : UpdatePlayerCustomStatusListener {
override fun onSuccess(result: Void?) {
Log.d("Battle", "更新玩家状态 成功")
// 房间内玩家会通过 OnPlayerCustomStatusChanged 回调收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "更新玩家状态 error ${error.code} ${error.message}")
}
})
import TapTapSDK
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapBattle.updatePlayerCustomStatus(updatePlayerStatus) { error in
if let error = error {
print("更新玩家状态 error \(error.code) \(error.message)")
} else {
print("更新玩家状态 成功")
// 房间内玩家会通过 OnPlayerCustomStatusChanged 回调收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
[TapTapBattle updatePlayerCustomStatus:updatePlayerStatus callback:^(NSError *error) {
if (error) {
NSLog(@"更新玩家状态 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"更新玩家状态 成功");
// 房间内玩家会通过 OnPlayerCustomStatusChanged 回调收到通知
}
}];
更新成功后,房间内玩家会通过 SDK 的 OnPlayerCustomStatusChanged 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家更新自定义状态
/// </summary>
/// <param name="playerId"> 更新了自定义状态的玩家ID </param>
/// <param name="status"> 新的状态 </param>
public void OnPlayerCustomStatusChanged(string playerId, int status)
{
LogMessage($"receive OnPlayerCustomStatusChanged {playerId}:{status}");
}
// 玩家更新自定义状态
@Override
public void onPlayerCustomStatusChanged(String playerId, int status) {
Log.d("Battle", "receive OnPlayerCustomStatusChanged " + playerId + ":" + status);
}
// 玩家更新自定义状态
override fun onPlayerCustomStatusChanged(playerId: String, status: Int) {
Log.d("Battle", "receive OnPlayerCustomStatusChanged $playerId:$status")
}
// 玩家更新自定义状态
func onPlayerCustomStatusChanged(playerId: String, status: Int) {
print("receive OnPlayerCustomStatusChanged \(playerId):\(status)")
}
// 玩家更新自定义状态
- (void)onPlayerCustomStatusChanged:(NSString *)playerId status:(int)status {
NSLog(@"receive OnPlayerCustomStatusChanged %@:%d", playerId, status);
}
更新玩家自定义属性
每个玩家均可更新自身的自定义属性数据,可用于设置玩家的基础用户信息、游戏等级等数据,示例如下:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
await TapTapOnlineBattle.UpdatePlayerCustomProperties(
updatePlayerProperty // 玩家属性,最大支持 2048 字节
);
LogMessage(" 更新玩家属性 成功 ");
// 房间内玩家会通过 OnPlayerCustomPropertiesChanged 回调收到通知
}
catch (TapException e)
{
LogMessage($"更新玩家属性 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.UpdatePlayerCustomPropertiesListener;
import com.taptap.sdk.kit.internal.exception.TapError;
TapTapBattle.updatePlayerCustomProperties(updatePlayerProperty, new UpdatePlayerCustomPropertiesListener() {
@Override
public void onSuccess(Void result) {
Log.d("Battle", "更新玩家属性 成功");
// 房间内玩家会通过 OnPlayerCustomPropertiesChanged 回调收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "更新玩家属性 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.UpdatePlayerCustomPropertiesListener
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
TapTapBattle.updatePlayerCustomProperties(updatePlayerProperty, object : UpdatePlayerCustomPropertiesListener {
override fun onSuccess(result: Void?) {
Log.d("Battle", "更新玩家属性 成功")
// 房间内玩家会通过 OnPlayerCustomPropertiesChanged 回调收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "更新玩家属性 error ${error.code} ${error.message}")
}
})
import TapTapSDK
TapTapBattle.updatePlayerCustomProperties(updatePlayerProperty) { error in
if let error = error {
print("更新玩家属性 error \(error.code) \(error.message)")
} else {
print("更新玩家属性 成功")
// 房间内玩家会通过 OnPlayerCustomPropertiesChanged 回调收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
[TapTapBattle updatePlayerCustomProperties:updatePlayerProperty callback:^(NSError *error) {
if (error) {
NSLog(@"更新玩家属性 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"更新玩家属性 成功");
// 房间内玩家会通过 OnPlayerCustomPropertiesChanged 回调收到通知
}
}];
更新成功后,房间内玩家会通过 SDK 的 OnPlayerCustomPropertiesChanged 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家更新自定义属性
/// </summary>
/// <param name="playerId"> 更新了 自定义属性的玩家ID </param>
/// <param name="properties"> 新的属性值 </param>
public void OnPlayerCustomPropertiesChanged(string playerId, string properties)
{
LogMessage($"receive OnPlayerCustomPropertiesChanged {playerId}:{properties}");
}
// 玩家更新自定义属性
@Override
public void onPlayerCustomPropertiesChanged(String playerId, String properties) {
Log.d("Battle", "receive OnPlayerCustomPropertiesChanged " + playerId + ":" + properties);
}
// 玩家更新自定义属性
override fun onPlayerCustomPropertiesChanged(playerId: String, properties: String) {
Log.d("Battle", "receive OnPlayerCustomPropertiesChanged $playerId:$properties")
}
// 玩家更新自定义属性
func onPlayerCustomPropertiesChanged(playerId: String, properties: String) {
print("receive OnPlayerCustomPropertiesChanged \(playerId):\(properties)")
}
// 玩家更新自定义属性
- (void)onPlayerCustomPropertiesChanged:(NSString *)playerId properties:(NSString *)properties {
NSLog(@"receive OnPlayerCustomPropertiesChanged %@:%@", playerId, properties);
}
离开房间
当房间内玩家需要离开当前房间时,可调用如下接口:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
await TapTapOnlineBattle.LeaveRoom();
LogMessage(" 离开房间成功 ");
// 房间内其他玩家通过 OnPlayerLeft 收到通知
}
catch (TapException e)
{
LogMessage($"离开房间 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.LeaveRoomListener;
import com.taptap.sdk.kit.internal.exception.TapError;
TapTapBattle.leaveRoom(new LeaveRoomListener() {
@Override
public void onSuccess(Void result) {
Log.d("Battle", "离开房间成功");
// 房间内其他玩家通过 OnPlayerLeft 收到通知
}
@Override
public void onError(TapError error) {
Log.e("Battle", "离开房间 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.LeaveRoomListener
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
TapTapBattle.leaveRoom(object : LeaveRoomListener {
override fun onSuccess(result: Void?) {
Log.d("Battle", "离开房间成功")
// 房间内其他玩家通过 OnPlayerLeft 收到通知
}
override fun onError(error: TapError) {
Log.e("Battle", "离开房间 error ${error.code} ${error.message}")
}
})
import TapTapSDK
TapTapBattle.leaveRoom { error in
if let error = error {
print("离开房间 error \(error.code) \(error.message)")
} else {
print("离开房间成功")
// 房间内其他玩家通过 OnPlayerLeft 收到通知
}
}
#import <TapTapSDK/TapTapSDK.h>
[TapTapBattle leaveRoom:^(NSError *error) {
if (error) {
NSLog(@"离开房间 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"离开房间成功");
// 房间内其他玩家通过 OnPlayerLeft 收到通知
}
}];
调用成功后,房间内其他玩家通过 SDK 的 OnPlayerLeft 收到通知,如果离开的玩家是房主,则会重新指定房间内其他玩家为房主。
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家离开房间
/// </summary>
/// <param name="roomId"> 房间ID </param>
/// <param name="roomOwnerId"> 房主ID。如果离开的是房主,则roomOwnerId为新房主ID;反之,为原房主ID</param>
/// <param name="playerId"> 离开房间的玩家ID </param>
public void OnPlayerLeft(string roomId, string roomOwnerId, string playerId)
{
LogMessage($"receive OnPlayerLeft {roomId}:{roomOwnerId}:{playerId}");
}
// 玩家离开房间
@Override
public void onPlayerLeft(String roomId, String roomOwnerId, String playerId) {
Log.d("Battle", "receive OnPlayerLeft " + roomId + ":" + roomOwnerId + ":" + playerId);
}
// 玩家离开房间
override fun onPlayerLeft(roomId: String, roomOwnerId: String, playerId: String) {
Log.d("Battle", "receive OnPlayerLeft $roomId:$roomOwnerId:$playerId")
}
// 玩家离开房间
func onPlayerLeft(roomId: String, roomOwnerId: String, playerId: String) {
print("receive OnPlayerLeft \(roomId):\(roomOwnerId):\(playerId)")
}
// 玩家离开房间
- (void)onPlayerLeft:(NSString *)roomId roomOwnerId:(NSString *)roomOwnerId playerId:(NSString *)playerId {
NSLog(@"receive OnPlayerLeft %@:%@:%@", roomId, roomOwnerId, playerId);
}
踢出玩家
当房主需要将玩家踢出房间时,可调用如下接口:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
using TapSDK.OnlineBattle;
try
{
// kickPlayerId 玩家 ID
await TapTapOnlineBattle.KickRoomPlayer(kickPlayerId);
LogMessage(" 踢出玩家 成功 ");
}
catch (TapException e)
{
LogMessage($"踢出玩家 error {e.Code} {e.Message}");
}
import com.taptap.sdk.battle.TapTapBattle;
import com.taptap.sdk.battle.callback.KickRoomPlayerListener;
import com.taptap.sdk.kit.internal.exception.TapError;
// kickPlayerId 玩家 ID
TapTapBattle.kickRoomPlayer(kickPlayerId, new KickRoomPlayerListener() {
@Override
public void onSuccess(Void result) {
Log.d("Battle", "踢出玩家 成功");
}
@Override
public void onError(TapError error) {
Log.e("Battle", "踢出玩家 error " + error.code + " " + error.message);
}
});
import com.taptap.sdk.battle.TapTapBattle
import com.taptap.sdk.battle.callback.KickRoomPlayerListener
import com.taptap.sdk.kit.internal.exception.TapError
import android.util.Log
// kickPlayerId 玩家 ID
TapTapBattle.kickRoomPlayer(kickPlayerId, object : KickRoomPlayerListener {
override fun onSuccess(result: Void?) {
Log.d("Battle", "踢出玩家 成功")
}
override fun onError(error: TapError) {
Log.e("Battle", "踢出玩家 error ${error.code} ${error.message}")
}
})
import TapTapSDK
// kickPlayerId 玩家 ID
TapTapBattle.kickRoomPlayer(kickPlayerId) { error in
if let error = error {
print("踢出玩家 error \(error.code) \(error.message)")
} else {
print("踢出玩家 成功")
}
}
#import <TapTapSDK/TapTapSDK.h>
// kickPlayerId 玩家 ID
[TapTapBattle kickRoomPlayer:kickPlayerId callback:^(NSError *error) {
if (error) {
NSLog(@"踢出玩家 error %ld %@", error.code, error.localizedDescription);
} else {
NSLog(@"踢出玩家 成功");
}
}];
调用成功后,对应玩家会通过 SDK 的 OnPlayerKicked 回调收到通知:
- Unity
- Android Java
- Android Kotlin
- iOS Swift
- iOS Objective-C
/// <summary>
/// 玩家被踢出
/// </summary>
/// <param name="roomId"> 被踢玩家所属房间ID </param>
/// <param name="playerId"> 被踢玩家ID </param>
public void OnPlayerKicked(string roomId, string playerId)
{
LogMessage($"receive OnPlayerKicked {roomId}:{playerId}");
}
// 玩家被踢出
@Override
public void onPlayerKicked(String roomId, String playerId) {
Log.d("Battle", "receive OnPlayerKicked " + roomId + ":" + playerId);
}
// 玩家被踢出
override fun onPlayerKicked(roomId: String, playerId: String) {
Log.d("Battle", "receive OnPlayerKicked $roomId:$playerId")
}
// 玩家被踢出
func onPlayerKicked(roomId: String, playerId: String) {
print("receive OnPlayerKicked \(roomId):\(playerId)")
}
// 玩家被踢出
- (void)onPlayerKicked:(NSString *)roomId playerId:(NSString *)playerId {
NSLog(@"receive OnPlayerKicked %@:%@", roomId, playerId);
}