public override Task <RoomPlayerData> addAIPlayer()
{
RoomPlayerData aiPlayerData = new RoomPlayerData(Guid.NewGuid().GetHashCode(), "AI", RoomPlayerType.ai);
//通知其他玩家添加AI玩家
return(Task.FromResult(aiPlayerData));
}
/// <summary>
/// 收到玩家加入房间的请求，玩家能否加入房间取决于客户端逻辑（比如房间是否已满）
/// </summary>
/// <param name="request"></param>
/// <param name="player"></param>
void reqJoinRoom(ConnectionRequest request, RoomPlayerData player)
{
log?.logTrace(request.RemoteEndPoint + $"({player.id}) 请求加入房间。");
RoomData roomData = null;
try
{
roomData = onJoinRoomReq?.Invoke(player);
}
catch (Exception e)
{
log?.log(request.RemoteEndPoint + "加入房间的请求被拒绝，原因：" + e);
request.Reject(createRPCResponseWriter(PacketType.joinResponse, e));
return;
}
//接受了加入请求，回复请求并广播房间更新信息。
NetPeer peer = request.Accept();
_playerInfoDict[player.id] = new LANPlayerInfo()
{
ip = request.RemoteEndPoint,
peer = peer
};
// invokeBroadcast(nameof(ntfRoomAddPlayer), roomData.ID, player);
// invokeBroadcast(nameof(ntfUpdateRoom), roomData);
}
/// <summary>
/// 向房间内的玩家和局域网中的其他玩家发送房间的更新信息。
/// </summary>
/// <param name="roomData"></param>
/// <returns></returns>
public Task AddPlayer(RoomPlayerData playerData)
{
log?.logTrace($"添加玩家{playerData.id}");
_hostRoomData.playerDataList.Add(playerData);
return(NotifyPlayerDataChange(playerData));
}
public override Task <RoomData> createRoom(RoomPlayerData hostPlayerData)
{
RoomData data = new RoomData();
data.playerDataList.Add(hostPlayerData);
data.ownerId = hostPlayerData.id;
return(Task.FromResult(data));
}
/// <summary>
/// 局域网默认玩家使用随机Guid，没有玩家名字
/// </summary>
/// <returns></returns>
public override RoomPlayerData getJoinPlayerData()
{
if (_playerData == null)
{
_playerData = new RoomPlayerData(Guid.NewGuid().GetHashCode(), "玩家1", RoomPlayerType.human);
}
return(_playerData);
}
/// <summary>
/// 局域网络构造器，包括RPC方法注册。
/// </summary>
/// <param name="logger"></param>
public LANNetworking(string name, ILogger logger) : base("LAN", logger)
{
// todo: 局域网的玩家应当随机分配玩家名称
_playerData = new RoomPlayerData(Guid.NewGuid().GetHashCode(), name, RoomPlayerType.human);
addRPCMethod(this, typeof(IRoomRPCMethodHost));
addRPCMethod(this, typeof(ILANRPCMethodHost));
addRPCMethod(this, typeof(ILANRPCMethodClient));
}
RoomData IRoomRPCMethodHost.requestJoinRoom(RoomPlayerData player)
{
log?.logTrace($"接收到玩家{player.id}加入请求。");
RoomData data = onConfirmJoinReq.Invoke(player);
// 更新房间信息
// 不需要在这里添加玩家信息，玩家信息已经在连接时就添加了。
_ = NotifyPlayerDataChange(player);
return(data);
}
public async Task createOnlineRoom()
{
logger?.log("客户端创建在线房间");
RoomPlayerData localPlayerData = curNetwork.getJoinPlayerData();
RoomData data = await curNetwork.createRoom(localPlayerData);
room = new Room(data);
room.addPlayer(new ClientLocalRoomPlayer(localPlayerData.id));
localPlayer = room.getPlayer(localPlayerData.id);
}
IEnumerator removePlayerAssert(ClientLogic client)
{
RoomData room = client.room;
RoomPlayerData player = new RoomPlayerData("AI", RoomPlayerType.ai);
room.playerDataList.Add(player);
room.playerDataList.Remove(player);
Assert.Null(room.getPlayer(player.id));
yield break;
}
public async Task createLocalRoom()
{
logger?.log("客户端创建本地房间");
room = new RoomData(string.Empty);
localPlayer = new RoomPlayerData(Guid.NewGuid().GetHashCode(), "本地玩家", RoomPlayerType.human);
room.playerDataList.Add(localPlayer);
room.ownerId = localPlayer.id;
isLocalRoom = true;
}
/// <summary>
/// 获取当前用户的数据
/// </summary>
/// <returns></returns>
public override RoomPlayerData GetSelfPlayerData()
{
// 仅在更换了用户后更新这个PlayerData
var info = serverClient.GetUserInfo(serverClient.UID);
if (localPlayer?.id != info.UID)
{
localPlayer = new RoomPlayerData(info.UID, info.Name, RoomPlayerType.human);
}
return(localPlayer);
}
void IRoomRPCMethodClient.updatePlayerData(RoomPlayerData data)
{
log?.logTrace($"{name} 收到玩家信息改变事件。玩家信息: {data}");
for (int i = 0; i < cachedRoomData.playerDataList.Count; i++)
{
if (cachedRoomData.playerDataList[i].id == data.id)
{
cachedRoomData.playerDataList[i] = data;
}
}
OnRoomPlayerDataChanged?.Invoke(cachedRoomData.playerDataList.ToArray());
}
public async Task roomAddAIPlayer()
{
if (curNetwork == null)
{
room.addPlayer(new AIRoomPlayer(), new RoomPlayerData("AI", RoomPlayerType.ai));
}
else
{
RoomPlayerData aiPlayerData = await curNetwork.addAIPlayer();
room.addPlayer(new AIRoomPlayer(aiPlayerData.id), aiPlayerData);
}
}
private Task NotifyPlayerDataChange(RoomPlayerData playerData)
{
// 房间公共信息更新
updateRoomInfo();
// 提示上层玩家修改了
invokeOnRoomPlayerDataChanged(_hostRoomData.playerDataList.ToArray());
// 向房间中的其他玩家发送通知房间添加玩家
return(Task.WhenAll(_playerInfoDict.
Where(i => i.Key != playerData.id).
Select(i => invoke <object>(i.Value.peer, nameof(IRoomRPCMethodClient.onPlayerAdd), playerData))));
}
// Start is called before the first frame update
public override void OnStartLocalPlayer()
{
if (Instance != null)
{
this.JoinRoomChannel();
return;
}
Instance = this;
this.matchIdentifier = RoomSettings.Instance.roomUniqueIdentifier;
this.vivoxVoiceManager = VivoxVoiceManager.Instance;
this.roomPlayerData = GetComponent <RoomPlayerData>();
vivoxVoiceManager.Login(this.roomPlayerData.PlayerIndentifier);
vivoxVoiceManager.OnUserLoggedInEvent += OnLogin;
}
protected override void OnConnectionRequest(ConnectionRequest request)
{
PacketType packetType = (PacketType)request.Data.GetInt();
switch (packetType)
{
case PacketType.joinRequest:
RoomPlayerData joinPlayerData = BsonSerializer.Deserialize <RoomPlayerData>(request.Data.GetString());
reqJoinRoom(request, joinPlayerData);
break;
default:
log?.log(name + "收到未知的请求连接类型");
break;
}
}
/// <summary>
/// 处理玩家连接请求，判断是否可以连接
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
private RoomData onJoinRoomReq(RoomPlayerData player)
{
if (room == null)
{
throw new InvalidOperationException("房间不存在");
}
if (room.maxPlayerCount < 1 || room.playerDataList.Count < room.maxPlayerCount)
{
player.state = ERoomPlayerState.connecting;
room.playerDataList.Add(player);
return(room);
}
else
{
throw new InvalidOperationException("房间已满");
}
}
/// <summary>
/// 将玩家加入房间，然后返回一个房间信息
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
private RoomData onConfirmJoinReq(RoomPlayerData player)
{
if (room == null)
{
throw new InvalidOperationException("房间不存在");
}
player = room.playerDataList.Find(p => p.id == player.id);
if (player != null)
{
player.state = ERoomPlayerState.connected;
}
else
{
throw new NullReferenceException("房间中不存在玩家" + player.name);
}
return(room);
}
public void UpdatePanel(RoomPlayerData data)
{
//playersText.text = "";
string str = "";
for (int i = 0; i < ps.Count; i++)
{
ps[i].transform.SetParent(temp.transform);
ps[i].SetActive(false);
pools.Add(ps[i]);
}
ps.Clear();
bool isStart = true;
foreach (var item in data.GetPlayersInfo().Keys)
{
if (data.GetPlayersInfo()[item].canStart)
{
str = "等待开始游戏";
}
else
{
str = "玩家准备中";
isStart = false;
}
GameObject obj = null;
if (pools.Count > 0)
{
obj = pools[0];
pools.RemoveAt(0);
}
else
{
obj = Instantiate <GameObject>(player);
}
obj.transform.SetParent(players.transform);
obj.transform.localScale = Vector3.one;
obj.SetActive(true);
obj.transform.Find("NameText").GetComponent <Text>().text = "IP: " + item;
obj.transform.Find("StartText").GetComponent <Text>().text = str;
ps.Add(obj);
//playersText.text += "玩家" + (i + 1) + " -- IP: " + item + " --- " + str + "\n";
}
startButton.interactable = isStart;
}
public Task addAIPlayer()
{
logger?.log("主机添加AI玩家");
RoomPlayerData playerData = new RoomPlayerData(Guid.NewGuid().GetHashCode(), "AI", RoomPlayerType.ai);
var host = curNetwork as INetworkingV3LANHost;
if (!isLocalRoom && host != null)
{
return(host.AddPlayer(playerData));
}
else
{
// 本地玩家。
room.playerDataList.Add(playerData);
}
return(Task.CompletedTask);
}
void IRoomRPCMethodClient.onPlayerAdd(RoomPlayerData data)
{
log?.logTrace($"{name} 收到新增玩家事件。玩家信息：{data}");
if (cachedRoomData.containsPlayer(data.id))
{
log?.logWarn($"{name} 的房间信息中已经存在ID为{data.id}的玩家，但却收到了 onPlayerAdd 事件，这是有问题的。");
for (int i = 0; i < cachedRoomData.playerDataList.Count; i++)
{
if (cachedRoomData.playerDataList[i].id == data.id)
{
cachedRoomData.playerDataList[i] = data;
}
}
}
else
{
cachedRoomData.playerDataList.Add(data);
}
OnRoomPlayerDataChanged?.Invoke(cachedRoomData.playerDataList.ToArray());
}
public void FromBytes(byte[] data, ref int offset)
{
int roomID = BitConverter.ToInt32(data, offset);
offset += 4;
int nameLength = (int)data[offset++];
string name = Encoding.UTF8.GetString(data, offset, nameLength);
offset += nameLength;
int maxPlayers = (int)data[offset++];
int mapID = (int)data[offset++];
int creatorID = (int)data[offset++];
int playerAmount = (int)data[offset++];
RoomPlayerInfo[] players = new RoomPlayerInfo[playerAmount];
for (int i = 0; i < playerAmount; i++)
{
players[i] = new RoomPlayerData(data, ref offset).Player;
}
Room = new GameRoom(roomID, name, maxPlayers, mapID, creatorID);
Room.Players.AddRange(players);
}
/// <summary>
/// Called on every NetworkBehaviour when it is activated on a client.
/// <para>Objects on the host have this function called, as there is a local client on the host. The values of SyncVars on object are guaranteed to be initialized correctly with the latest state from the server when this function is called on the client.</para>
/// </summary>
public override void OnStartClient()
{
this.roomPlayerData = GetComponent <RoomPlayerData>();
}
protected override void HandleMessage(TypedPackage message)
{
Debug.Log(string.Format("Msg: {0} of length {1}.", message.Type, message.Data.Length));
if (message.Type == PackageType.LoginSucceed)
{
try
{
LoginSucceedData data = new LoginSucceedData(message.Data, ref message.Offset);
_playerID = data.PlayerID;
_udpConnectionKey = data.UdpConnectKey;
OnLogedIn();
}
catch (Exception e)
{
Debug.Log("Failed to parse: " + e.ToString());
}
BeginUdpRegister();
}
else if (message.Type == PackageType.LoginFailed)
{
OnLoginFailed();
}
else if (message.Type == PackageType.RoomCreated)
{
OnCreatedRoom();
}
else if (message.Type == PackageType.JoinedRoom)
{
JoinedRoomInfoData data;
try
{
data = new JoinedRoomInfoData(message.Data, ref message.Offset);
ConnectedRoom = data.Room;
OnJoinedRoom();
}
catch (Exception e)
{
Debug.Log("Failed to parse data: " + e.Message + " | " + e.TargetSite + " | " + e.StackTrace);
}
}
else if (message.Type == PackageType.RoomList)
{
RoomListData data = new RoomListData(message.Data, ref message.Offset);
OpenRooms = data.Rooms;
OnReceivedRooms();
}
else if (message.Type == PackageType.OtherJoinedRoom)
{
RoomPlayerInfo playerInfo = new RoomPlayerData(message.Data, ref message.Offset).Player;
ConnectedRoom.Players.Add(playerInfo);
OnOtherJoinedRoom(playerInfo);
}
else if (message.Type == PackageType.OtherLeftRoom)
{
PlayerIDData playerInfo = new PlayerIDData(message.Data, ref message.Offset);
RoomPlayerInfo player = null;
for (int i = ConnectedRoom.Players.Count - 1; i >= 0; i--)
{
if (ConnectedRoom.Players[i].PlayerID == playerInfo.PlayerID)
{
player = ConnectedRoom.Players[i];
ConnectedRoom.Players.RemoveAt(i);
break;
}
}
if (player != null) OnOtherLeftRoom(player);
else Debug.Log("Could not find player to remove");
}
else if (message.Type == PackageType.OtherChangedSetup)
{
// Parse
OtherPlayerSetupData info = new OtherPlayerSetupData(message.Data, ref message.Offset);
// Find player of id
RoomPlayerInfo foundPlayer = null;
foreach (RoomPlayerInfo player in ConnectedRoom.Players)
{
if (player.PlayerID == info.PlayerID)
{
foundPlayer = player;
break;
}
}
// Change setup of player
if (foundPlayer != null)
{
foundPlayer.Setup = info.Setup;
OnOtherChangedSetup();
}
else
{
Debug.Log("Could not find player to remove");
}
}
else if (message.Type == PackageType.UDPRegistered)
{
_udpRegistered = true;
}
else if (message.Type == PackageType.RoomLoad)
{
RoomUdpSetupData msg = new RoomUdpSetupData(message.Data, ref message.Offset);
// Assign udp settings
foreach (PlayerUdpSetupData playerUDP in msg.UdpPlayerList)
{
foreach (RoomPlayerInfo player in ConnectedRoom.Players)
{
if (player.PlayerID == playerUDP.PlayerID)
{
player.UdpEP = playerUDP.EP;
break;
}
}
}
OnGameLoad();
}
else if (message.Type == PackageType.RoomStart)
{
OnGameStart();
}
else
{
base.HandleMessage(message);
}
}
