房间管理
核心流程

概念说明
- 房间: 玩家联机的虚拟空间,每个房间有唯一的房间 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.TapTapOnlineBattle;
import com.taptap.sdk.battle.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.battle.model.ErrorResponse;
import java.util.HashMap;
import java.util.Map;
// 定义匹配参数
Map<String, String> matchParams = new HashMap<>();
// 定义房间配置,构造参数顺序:maxPlayerCount, type, matchParams, name, customProperties
RoomConfig roomConfig = new RoomConfig(
roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
roomType, // 房间类型,最大32字节,必填
matchParams, // 房间匹配参数,选填,最大支持3个K/V对, K最大32字节,V最大64字节
roomName, // 房间名称,最大64个字节,选填
roomProperty // 自定义房间属性,最大2048字节,选填
);
// 定义玩家配置,构造参数顺序:customStatus, customProperties
PlayerConfig playerConfig = new PlayerConfig(
playerCustomStatus, // 自定义玩家状态,整型,选填
playerProperty // 自定义玩家属性,选填
);
// 创建房间配置
CreateRoomConfig config = new CreateRoomConfig(roomConfig, playerConfig);
TapTapOnlineBattle.createRoom(config, new CreateRoomListener() {
@Override
public void onSuccess(RoomInfo roomInfo) {
Log.d("Battle", "创建房间成功 " + roomInfo);
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "创建房间 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.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.battle.model.ErrorResponse
import android.util.Log
// 定义匹配参数
val matchParams = mutableMapOf<String, String>()
// 定义房间配置
val roomConfig = RoomConfig(
maxPlayerCount = roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType, // 房间类型,最大32字节,必填
matchParams = matchParams, // 房间匹配参数,选填
name = roomName, // 房间名称,最大64个字节,选填
customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
)
// 定义玩家配置
val playerConfig = PlayerConfig(
customStatus = playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties = playerProperty // 自定义玩家属性,选填
)
// 创建房间配置
val config = CreateRoomConfig(roomConfig, playerConfig)
TapTapOnlineBattle.createRoom(request = config, listener = object : CreateRoomListener {
override fun onSuccess(roomInfo: RoomInfo) {
Log.d("Battle", "创建房间成功 $roomInfo")
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "创建房间 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
// 定义匹配参数
let matchParams: [String: String] = [:]
// 定义房间配置
let roomConfig = RoomConfig(
maxPlayerCount: roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type: roomType, // 房间类型,最大32字节,必填
matchParams: matchParams, // 房间匹配参数,选填
name: roomName, // 房间名称,最大64个字节,选填
customProperties: roomProperty // 自定义房间属性,最大2048字节,选填
)
// 定义玩家配置
let playerConfig = PlayerConfig(
customStatus: playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties: playerProperty // 自定义玩家属性,选填
)
// 创建房间配置
let config = CreateRoomConfig(roomConfig: roomConfig, playerConfig: playerConfig)
class MyCreateRoomListener: CreateRoomListener {
func onSuccess(roomInfo: RoomInfo) {
print("创建房间成功 \(roomInfo)")
}
func onFailure(error: ErrorResponse) {
print("创建房间 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.createRoom(request: config, listener: MyCreateRoomListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
// 定义匹配参数
NSDictionary<NSString *, NSString *> *matchParams = @{};
// 定义房间配置(maxPlayerCount, type, matchParams, name, customProperties)
RoomConfig *roomConfig = [[RoomConfig alloc] initWithMaxPlayerCount:roomMaxPlayerCount
type:roomType
matchParams:matchParams
name:roomName
customProperties:roomProperty];
// 定义玩家配置(customStatus, customProperties)
PlayerConfig *playerConfig = [[PlayerConfig alloc] initWithCustomStatus:playerCustomStatus
customProperties:playerProperty];
// 创建房间配置
CreateRoomConfig *config = [[CreateRoomConfig alloc] initWithRoomConfig:roomConfig playerConfig:playerConfig];
[TapTapOnlineBattle createRoomWithRequest:config listener:[[MyCreateRoomListener alloc] init]];
匹配房间
匹配房间时使用的配置参数和创建房间一致,当没有满足条件的房间存在时,会自动创建一个新房间, 匹配成功后返回对应的房间信息。
- 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.TapTapOnlineBattle;
import com.taptap.sdk.battle.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.battle.model.ErrorResponse;
import java.util.HashMap;
import java.util.Map;
// 定义匹配参数
Map<String, String> matchParams = new HashMap<>();
// 定义房间配置,构造参数顺序:maxPlayerCount, type, matchParams, name, customProperties
RoomConfig roomConfig = new RoomConfig(
roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
roomType, // 房间类型,最大32字节,必填
matchParams, // 房间匹配参数,选填
"", // 房间名称,匹配房间时无需设置
roomProperty // 自定义房间属性,最大2048字节,选填
);
// 定义玩家配置,构造参数顺序:customStatus, customProperties
PlayerConfig playerConfig = new PlayerConfig(
playerCustomStatus, // 自定义玩家状态,整型,选填
playerProperty // 自定义玩家属性,选填
);
// 匹配房间配置
MatchRoomConfig config = new MatchRoomConfig(roomConfig, playerConfig);
TapTapOnlineBattle.matchRoom(config, new MatchRoomListener() {
@Override
public void onSuccess(RoomInfo roomInfo) {
Log.d("Battle", "匹配房间成功 " + roomInfo);
// 如果此时是加入已存在的房间,房间内其他玩家会通过 onPlayerEntered 回调收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "匹配房间 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.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.battle.model.ErrorResponse
import android.util.Log
// 定义匹配参数
val matchParams = mutableMapOf<String, String>()
// 定义房间配置
val roomConfig = RoomConfig(
maxPlayerCount = roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type = roomType, // 房间类型,最大32字节,必填
matchParams = matchParams, // 房间匹配参数,选填
customProperties = roomProperty // 自定义房间属性,最大2048字节,选填
)
// 定义玩家配置
val playerConfig = PlayerConfig(
customStatus = playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties = playerProperty // 自定义玩家属性,选填
)
// 匹配房间配置
val config = MatchRoomConfig(roomConfig, playerConfig)
TapTapOnlineBattle.matchRoom(request = config, listener = object : MatchRoomListener {
override fun onSuccess(roomInfo: RoomInfo) {
Log.d("Battle", "匹配房间成功 $roomInfo")
// 如果此时是加入已存在的房间,房间内其他玩家会通过 onPlayerEntered 回调收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "匹配房间 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
// 定义匹配参数
let matchParams: [String: String] = [:]
// 定义房间配置
let roomConfig = RoomConfig(
maxPlayerCount: roomMaxPlayerCount, // 房间最大支持人数,取值范围为[1, 20],必填
type: roomType, // 房间类型,最大32字节,必填
matchParams: matchParams, // 房间匹配参数,选填
name: "", // 房间名称,匹配房间时无需设置
customProperties: roomProperty // 自定义房间属性,最大2048字节,选填
)
// 定义玩家配置
let playerConfig = PlayerConfig(
customStatus: playerCustomStatus, // 自定义玩家状态,整型,选填
customProperties: playerProperty // 自定义玩家属性,选填
)
// 匹配房间配置
let config = MatchRoomConfig(roomConfig: roomConfig, playerConfig: playerConfig)
class MyMatchRoomListener: MatchRoomListener {
func onSuccess(roomInfo: RoomInfo) {
print("匹配房间成功 \(roomInfo)")
// 如果此时是加入已存在的房间,房间内其他玩家会通过 onPlayerEntered 回调收到通知
}
func onFailure(error: ErrorResponse) {
print("匹配房间 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.matchRoom(request: config, listener: MyMatchRoomListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
// 定义匹配参数
NSDictionary<NSString *, NSString *> *matchParams = @{};
// 定义房间配置(maxPlayerCount, type, matchParams, name, customProperties)
RoomConfig *roomConfig = [[RoomConfig alloc] initWithMaxPlayerCount:roomMaxPlayerCount
type:roomType
matchParams:matchParams
name:@""
customProperties:roomProperty];
// 定义玩家配置(customStatus, customProperties)
PlayerConfig *playerConfig = [[PlayerConfig alloc] initWithCustomStatus:playerCustomStatus
customProperties:playerProperty];
// 匹配房间配置
MatchRoomConfig *config = [[MatchRoomConfig alloc] initWithRoomConfig:roomConfig playerConfig:playerConfig];
[TapTapOnlineBattle matchRoomWithRequest:config listener:[[MyMatchRoomListener alloc] init]];
如果此时是加入已存在的房间,房间内其他玩家会通过 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)onPlayerEnteredWithRoomId:(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.TapTapOnlineBattle;
import com.taptap.sdk.battle.GetRoomListListener;
import com.taptap.sdk.battle.model.RoomListData;
import com.taptap.sdk.battle.model.ErrorResponse;
TapTapOnlineBattle.getRoomList(roomType, offset, limit, new GetRoomListListener() {
@Override
public void onSuccess(RoomListData data) {
Log.d("Battle", "查询房间列表成功 " + data);
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "查询房间列表 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.GetRoomListListener
import com.taptap.sdk.battle.model.RoomListData
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
TapTapOnlineBattle.getRoomList(
roomType = roomType,
offset = offset,
limit = limit,
listener = object : GetRoomListListener {
override fun onSuccess(data: RoomListData) {
Log.d("Battle", "查询房间列表成功 $data")
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "查询房间列表 error ${error.code} ${error.msg}")
}
}
)
import TapOnlineBattleSDK
class MyGetRoomListListener: GetRoomListListener {
func onSuccess(data: RoomListData) {
print("查询房间列表成功 \(data)")
}
func onFailure(error: ErrorResponse) {
print("查询房间列表 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.getRoomList(roomType: roomType, offset: offset, limit: limit, listener: MyGetRoomListListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
[TapTapOnlineBattle getRoomListWithRoomType:roomType offset:offset limit:limit listener:[[MyGetRoomListListener alloc] init]];
首次请求时,请求参数中 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.TapTapOnlineBattle;
import com.taptap.sdk.battle.JoinRoomListener;
import com.taptap.sdk.battle.model.PlayerConfig;
import com.taptap.sdk.battle.model.RoomInfo;
import com.taptap.sdk.battle.model.ErrorResponse;
// 玩家配置
PlayerConfig playerConfig = new PlayerConfig(
joinPlayerStatus, // 自定义玩家状态,整形,选填
joinPlayerProperty // 自定义玩家属性,选填
);
TapTapOnlineBattle.joinRoom(joinRoomId, playerConfig, new JoinRoomListener() {
@Override
public void onSuccess(RoomInfo roomInfo) {
Log.d("Battle", "加入房间成功 " + roomInfo);
// 其他玩家会通过 onPlayerEntered 回调收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "加入房间 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.JoinRoomListener
import com.taptap.sdk.battle.model.PlayerConfig
import com.taptap.sdk.battle.model.RoomInfo
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
// 玩家配置
val playerConfig = PlayerConfig(
customStatus = joinPlayerStatus, // 自定义玩家状态,整形,选填
customProperties = joinPlayerProperty // 自定义玩家属性,选填
)
TapTapOnlineBattle.joinRoom(
roomId = joinRoomId,
playerConfig = playerConfig,
listener = object : JoinRoomListener {
override fun onSuccess(roomInfo: RoomInfo) {
Log.d("Battle", "加入房间成功 $roomInfo")
// 其他玩家会通过 onPlayerEntered 回调收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "加入房间 error ${error.code} ${error.msg}")
}
}
)
import TapOnlineBattleSDK
// 玩家配置
let playerConfig = PlayerConfig(
customStatus: joinPlayerStatus, // 自定义玩家状态,整形,选填
customProperties: joinPlayerProperty // 自定义玩家属性,选填
)
class MyJoinRoomListener: JoinRoomListener {
func onSuccess(roomInfo: RoomInfo) {
print("加入房间成功 \(roomInfo)")
// 其他玩家会通过 onPlayerEntered 回调收到通知
}
func onFailure(error: ErrorResponse) {
print("加入房间 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.joinRoom(roomId: joinRoomId, playerConfig: playerConfig, listener: MyJoinRoomListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
// 玩家配置(customStatus, customProperties)
PlayerConfig *playerConfig = [[PlayerConfig alloc] initWithCustomStatus:joinPlayerStatus
customProperties:joinPlayerProperty];
[TapTapOnlineBattle joinRoomWithRoomId:joinRoomId playerConfig:playerConfig listener:[[MyJoinRoomListener alloc] init]];
加入成功后其他玩家也会通过 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)onPlayerEnteredWithRoomId:(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.TapTapOnlineBattle;
import com.taptap.sdk.battle.UpdateRoomPropertiesListener;
import com.taptap.sdk.battle.model.ErrorResponse;
TapTapOnlineBattle.updateRoomProperties(updateRoomName, updateRoomProperty, new UpdateRoomPropertiesListener() {
@Override
public void onSuccess() {
Log.d("Battle", "更新房间属性 成功");
// 所有玩家会通过 onRoomPropertiesChanged 回调收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "更新房间属性 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.UpdateRoomPropertiesListener
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
TapTapOnlineBattle.updateRoomProperties(
roomName = updateRoomName,
properties = updateRoomProperty,
listener = object : UpdateRoomPropertiesListener {
override fun onSuccess() {
Log.d("Battle", "更新房间属性 成功")
// 所有玩家会通过 onRoomPropertiesChanged 回调收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "更新房间属性 error ${error.code} ${error.msg}")
}
}
)
import TapOnlineBattleSDK
class MyUpdateRoomPropertiesListener: UpdateRoomPropertiesListener {
func onSuccess() {
print("更新房间属性 成功")
// 所有玩家会通过 onRoomPropertiesChanged 回调收到通知
}
func onFailure(error: ErrorResponse) {
print("更新房间属性 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.updateRoomProperties(
roomName: updateRoomName,
properties: updateRoomProperty,
listener: MyUpdateRoomPropertiesListener()
)
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
[TapTapOnlineBattle updateRoomPropertiesWithRoomName:updateRoomName
properties:updateRoomProperty
listener:[[MyUpdateRoomPropertiesListener alloc] init]];
更新成功后所有玩家会通过 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)onRoomPropertiesChangedWithId:(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.TapTapOnlineBattle;
import com.taptap.sdk.battle.UpdatePlayerCustomStatusListener;
import com.taptap.sdk.battle.model.ErrorResponse;
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapOnlineBattle.updatePlayerCustomStatus(updatePlayerStatus, new UpdatePlayerCustomStatusListener() {
@Override
public void onSuccess() {
Log.d("Battle", "更新玩家状态 成功");
// 房间内玩家会通过 onPlayerCustomStatusChanged 回调收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "更新玩家状态 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.UpdatePlayerCustomStatusListener
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapOnlineBattle.updatePlayerCustomStatus(updatePlayerStatus, object : UpdatePlayerCustomStatusListener {
override fun onSuccess() {
Log.d("Battle", "更新玩家状态 成功")
// 房间内玩家会通过 onPlayerCustomStatusChanged 回调收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "更新玩家状态 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
class MyUpdateStatusListener: UpdatePlayerCustomStatusListener {
func onSuccess() {
print("更新玩家状态 成功")
// 房间内玩家会通过 onPlayerCustomStatusChanged 回调收到通知
}
func onFailure(error: ErrorResponse) {
print("更新玩家状态 error \(error.code) \(error.msg)")
}
}
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
TapTapOnlineBattle.updatePlayerCustomStatus(status: updatePlayerStatus, listener: MyUpdateStatusListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
// updatePlayerStatus 玩家自定义状态,例如 0 未就绪 1 已就绪
[TapTapOnlineBattle updatePlayerCustomStatusWithStatus:updatePlayerStatus listener:[[MyUpdateStatusListener alloc] init]];
更新成功后,房间内玩家会通过 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)onPlayerCustomStatusChangedWithPlayerId:(NSString *)playerId status:(NSInteger)status {
NSLog(@"receive OnPlayerCustomStatusChanged %@:%ld", playerId, (long)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.TapTapOnlineBattle;
import com.taptap.sdk.battle.UpdatePlayerCustomPropertiesListener;
import com.taptap.sdk.battle.model.ErrorResponse;
TapTapOnlineBattle.updatePlayerCustomProperties(updatePlayerProperty, new UpdatePlayerCustomPropertiesListener() {
@Override
public void onSuccess() {
Log.d("Battle", "更新玩家属性 成功");
// 房间内玩家会通过 onPlayerCustomPropertiesChanged 回调收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "更新玩家属性 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.UpdatePlayerCustomPropertiesListener
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
TapTapOnlineBattle.updatePlayerCustomProperties(updatePlayerProperty, object : UpdatePlayerCustomPropertiesListener {
override fun onSuccess() {
Log.d("Battle", "更新玩家属性 成功")
// 房间内玩家会通过 onPlayerCustomPropertiesChanged 回调收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "更新玩家属性 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
class MyUpdatePropertiesListener: UpdatePlayerCustomPropertiesListener {
func onSuccess() {
print("更新玩家属性 成功")
// 房间内玩家会通过 onPlayerCustomPropertiesChanged 回调收到通知
}
func onFailure(error: ErrorResponse) {
print("更新玩家属性 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.updatePlayerCustomProperties(properties: updatePlayerProperty, listener: MyUpdatePropertiesListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
[TapTapOnlineBattle updatePlayerCustomPropertiesWithProperties:updatePlayerProperty listener:[[MyUpdatePropertiesListener alloc] init]];
更新成功后,房间内玩家会通过 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)onPlayerCustomPropertiesChangedWithPlayerId:(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.TapTapOnlineBattle;
import com.taptap.sdk.battle.LeaveRoomListener;
import com.taptap.sdk.battle.model.ErrorResponse;
TapTapOnlineBattle.leaveRoom(new LeaveRoomListener() {
@Override
public void onSuccess() {
Log.d("Battle", "离开房间成功");
// 房间内其他玩家通过 onPlayerLeft 收到通知
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "离开房间 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.LeaveRoomListener
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
TapTapOnlineBattle.leaveRoom(object : LeaveRoomListener {
override fun onSuccess() {
Log.d("Battle", "离开房间成功")
// 房间内其他玩家通过 onPlayerLeft 收到通知
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "离开房间 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
class MyLeaveRoomListener: LeaveRoomListener {
func onSuccess() {
print("离开房间成功")
// 房间内其他玩家通过 onPlayerLeft 收到通知
}
func onFailure(error: ErrorResponse) {
print("离开房间 error \(error.code) \(error.msg)")
}
}
TapTapOnlineBattle.leaveRoom(listener: MyLeaveRoomListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
[TapTapOnlineBattle leaveRoomWithListener:[[MyLeaveRoomListener alloc] init]];
调用成功后,房间内其他玩家通过 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)onPlayerLeftWithRoomId:(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.TapTapOnlineBattle;
import com.taptap.sdk.battle.KickRoomPlayerListener;
import com.taptap.sdk.battle.model.ErrorResponse;
// kickPlayerId 玩家 ID
TapTapOnlineBattle.kickRoomPlayer(kickPlayerId, new KickRoomPlayerListener() {
@Override
public void onSuccess() {
Log.d("Battle", "踢出玩家 成功");
}
@Override
public void onFailure(ErrorResponse error) {
Log.e("Battle", "踢出玩家 error " + error.getCode() + " " + error.getMsg());
}
});
import com.taptap.sdk.battle.TapTapOnlineBattle
import com.taptap.sdk.battle.KickRoomPlayerListener
import com.taptap.sdk.battle.model.ErrorResponse
import android.util.Log
// kickPlayerId 玩家 ID
TapTapOnlineBattle.kickRoomPlayer(kickPlayerId, object : KickRoomPlayerListener {
override fun onSuccess() {
Log.d("Battle", "踢出玩家 成功")
}
override fun onFailure(error: ErrorResponse) {
Log.e("Battle", "踢出玩家 error ${error.code} ${error.msg}")
}
})
import TapOnlineBattleSDK
class MyKickPlayerListener: KickRoomPlayerListener {
func onSuccess() {
print("踢出玩家 成功")
}
func onFailure(error: ErrorResponse) {
print("踢出玩家 error \(error.code) \(error.msg)")
}
}
// kickPlayerId 玩家 ID
TapTapOnlineBattle.kickRoomPlayer(playerID: kickPlayerId, listener: MyKickPlayerListener())
#import <TapOnlineBattleSDK/TapOnlineBattleSDK-Swift.h>
// kickPlayerId 玩家 ID
[TapTapOnlineBattle kickRoomPlayerWithPlayerID:kickPlayerId listener:[[MyKickPlayerListener alloc] init]];
调用成功后,对应玩家会通过 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)onPlayerKickedWithRoomId:(NSString *)roomId playerId:(NSString *)playerId {
NSLog(@"receive OnPlayerKicked %@:%@", roomId, playerId);
}