public bool Serialize(RoomListData data)
{
bool ret = true;
for (int roomIndex = 0; roomIndex < WaitingUIManager.maxRoomNum; roomIndex++)
{
ret &= Serialize((byte)Encoding.Unicode.GetBytes(data.Rooms[roomIndex].RoomName).Length);
ret &= Serialize(data.Rooms[roomIndex].RoomName);
ret &= Serialize((byte)data.Rooms[roomIndex].DungeonId);
ret &= Serialize((byte)data.Rooms[roomIndex].DungeonLevel);
ret &= Serialize((byte)data.Rooms[roomIndex].PlayerNum);
ret &= Serialize((byte)data.Rooms[roomIndex].State);
for (int userIndex = 0; userIndex < WaitingUIManager.maxPlayerNum; userIndex++)
{
ret &= Serialize((byte)Encoding.Unicode.GetBytes(data.Rooms[roomIndex].RoomUserData[userIndex].UserName).Length);
ret &= Serialize(data.Rooms[roomIndex].RoomUserData[userIndex].UserName);
ret &= Serialize((byte)data.Rooms[roomIndex].RoomUserData[userIndex].UserGender);
ret &= Serialize((byte)data.Rooms[roomIndex].RoomUserData[userIndex].UserClass);
ret &= Serialize((byte)data.Rooms[roomIndex].RoomUserData[userIndex].UserLevel);
}
}
return(ret);
}
public RoomListPacket GetRoomList()
{
RoomListData roomListData = new RoomListData(room);
RoomListPacket roomListPacket = new RoomListPacket(roomListData);
return roomListPacket;
}
void OnGotRoomList(RoomListData rooms)
{
CreateRoomListItems(rooms);
fetchRoomListLoading.SetActive(false);
refreshButton.interactable = true;
}
private async void Client_RoomListUpdate(RoomListData data)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
listRooms(data.RoomNames);
});
}
//Server - 방 목록 수신
public void RoomList(DataPacket packet)
{
Debug.Log("방 목록 수신");
RoomListPacket roomListPacket = new RoomListPacket(packet.msg);
RoomListData roomListData = roomListPacket.GetData();
uiManager.WaitUIManager.SetRoom(roomListData);
}
public bool Deserialize(ref RoomListData element)
{
if (GetDataSize() == 0)
{
// 데이터가 설정되지 않았다.
return(false);
}
bool ret = true;
byte roomNameLength = 0;
string roomName;
byte dungeonId = 0;
byte dungeonLevel = 0;
byte playerNum = 0;
byte state = 0;
byte userNameLength = 0;
string userName;
byte userGender = 0;
byte userClass = 0;
byte userLevel = 0;
Room[] rooms;
RoomUserData[] roomUserData;
rooms = new Room[WaitingUIManager.maxRoomNum];
roomUserData = new RoomUserData[WaitingUIManager.maxPlayerNum];
for (int roomIndex = 0; roomIndex < WaitingUIManager.maxRoomNum; roomIndex++)
{
ret &= Deserialize(ref roomNameLength);
ret &= Deserialize(out roomName, roomNameLength);
ret &= Deserialize(ref dungeonId);
ret &= Deserialize(ref dungeonLevel);
ret &= Deserialize(ref playerNum);
ret &= Deserialize(ref state);
for (int userIndex = 0; userIndex < WaitingUIManager.maxPlayerNum; userIndex++)
{
ret &= Deserialize(ref userNameLength);
ret &= Deserialize(out userName, userNameLength);
ret &= Deserialize(ref userGender);
ret &= Deserialize(ref userClass);
ret &= Deserialize(ref userLevel);
roomUserData[userIndex] = new RoomUserData(userName, userGender, userClass, userLevel);
}
rooms[roomIndex] = new Room(roomName, dungeonId, dungeonLevel, roomUserData, playerNum, state);
}
element = new RoomListData(rooms);
return(ret);
}
void CreateRoomListItems(RoomListData rooms)
{
RoomListItem[] roomListItems = roomList.GetComponentsInChildren <RoomListItem>();
if (roomListItems != null)
{
for (int i = 0; i < roomListItems.Length; i++)
{
bool remain = false;
for (int j = 0; j < rooms.rooms.Length; j++)
{
if (roomListItems[i].room.roomID == rooms.rooms[j].roomID)
{
remain = true;
break;
}
}
if (!remain)
{
GameObject.Destroy(roomListItems[i].gameObject);
}
}
}
roomListItems = roomList.GetComponentsInChildren <RoomListItem>();
for (int i = 0; i < rooms.rooms.Length; i++)
{
RoomListItem roomListItem = null;
if (roomListItems != null)
{
for (int j = 0; j < roomListItems.Length; j++)
{
if (roomListItems[j].room.roomID == rooms.rooms[i].roomID)
{
roomListItem = roomListItems[j];
break;
}
}
}
if (roomListItem == null)
{
roomListItem = Instantiate(roomListItemPrefab) as RoomListItem;
roomListItem.transform.SetParent(roomList, false);
}
roomListItem.SetRoom(rooms.rooms[i]);
}
}
private void GetRoomList(ISession session)
{
List <RoomData> list = new List <RoomData>();
for (int i = 0; i < m_listRoom.Count; i++)
{
list.Add(m_listRoom[i].data);
}
RoomListData data = new RoomListData();
data.rooms = list;
m_net.Return(data);
}
private void OnGetRoomList(RoomListData data)
{
if (data != null)
{
m_listRoom = data.rooms;
for (int i = 0; i < m_listRoom.Count; i++)
{
Debuger.LogWarning(m_listRoom[i].ToString());
}
}
else
{
Debuger.LogWarning("房间列表为空！");
}
}
//Server - 방 목록 수신
public void RoomList(DataPacket packet)
{
Debug.Log("방 목록 수신");
RoomListPacket roomListPacket = new RoomListPacket(packet.msg);
RoomListData roomListData = roomListPacket.GetData();
UIManager.Instance.WaitingUIManager.SetRoomListData(roomListData);
if (SceneChanger.Instance.CurrentScene == SceneChanger.SceneName.LoadingScene)
{
SceneChanger.Instance.LoadingCheck[0] = true;
}
else if (SceneChanger.Instance.CurrentScene == SceneChanger.SceneName.WaitingScene)
{
UIManager.Instance.WaitingUIManager.SetRoom();
}
}
private void OnUpdateRoomList(RoomListData data)
{
if (data != null || data.rooms.Count == 0)
{
m_listRoom = data.rooms;
for (int i = 0; i < m_listRoom.Count; i++)
{
Debuger.Log(m_listRoom[i].ToString());
}
onUpdateRoomList.Invoke(m_listRoom);
}
else
{
m_listRoom = new List <RoomData>();
Debuger.LogWarning("房间列表为空！");
}
}
//Server - 방 목록 수신
public void RoomList(DataPacket packet)
{
Debug.Log("방 목록 수신");
RoomListPacket roomListPacket = new RoomListPacket(packet.msg);
RoomListData roomListData = roomListPacket.GetData();
uiManager.WaitingUIManager.SetRoomListData(roomListData);
for (int i = 0; i < WaitingUIManager.maxRoomNum; i++)
{
Debug.Log(roomListData.Rooms[i].RoomName);
Debug.Log(roomListData.Rooms[i].PlayerNum);
}
if (SceneChanger.Instance.CurrentScene == SceneChanger.SceneName.LoadingScene)
{
SceneChanger.Instance.LoadingCheck[0] = true;
}
}
public bool Deserialize(ref RoomListData element)
{
if (GetDataSize() == 0)
{
// 데이터가 설정되지 않았다.
return(false);
}
bool ret = true;
byte roomNameLength = 0;
string roomName;
byte dungeonId = 0;
byte dungeonLevel = 0;
byte[] userNameLength = new byte[WaitUIManager.maxPlayerNum];
string[] userName = new string[WaitUIManager.maxPlayerNum];
byte[] userGender = new byte[WaitUIManager.maxPlayerNum];
byte[] userClass = new byte[WaitUIManager.maxPlayerNum];
byte[] userLevel = new byte[WaitUIManager.maxPlayerNum];
for (int i = 0; i < WaitUIManager.maxRoomNum; i++)
{
ret &= Deserialize(ref roomNameLength);
ret &= Deserialize(out roomName, roomNameLength);
ret &= Deserialize(ref dungeonId);
ret &= Deserialize(ref dungeonLevel);
for (int j = 0; j < WaitUIManager.maxPlayerNum; j++)
{
ret &= Deserialize(ref userNameLength[j]);
ret &= Deserialize(out userName[j], userNameLength[j]);
ret &= Deserialize(ref userGender[j]);
ret &= Deserialize(ref userClass[j]);
ret &= Deserialize(ref userLevel[j]);
}
element.Rooms[i] = new Room(roomName, dungeonId, dungeonLevel, userName, userGender, userClass, userLevel);
}
return(ret);
}
public bool Serialize(RoomListData data)
{
bool ret = true;
for (int i = 0; i < WaitUIManager.maxRoomNum; i++)
{
ret &= Serialize((byte)Encoding.Unicode.GetBytes(data.Rooms[i].RoomName).Length);
ret &= Serialize(data.Rooms[i].RoomName);
ret &= Serialize(data.Rooms[i].DungeonId);
ret &= Serialize(data.Rooms[i].DungeonLevel);
for (int j = 0; j < WaitUIManager.maxPlayerNum; j++)
{
ret &= Serialize((byte)Encoding.Unicode.GetBytes(data.Rooms[i].UserName[j]).Length);
ret &= Serialize(data.Rooms[i].UserName[j]);
ret &= Serialize((byte)data.Rooms[i].UserGender[j]);
ret &= Serialize(data.Rooms[i].UserClass[j]);
ret &= Serialize(data.Rooms[i].UserLevel[j]);
}
}
return(ret);
}
public void SetRoom(RoomListData roomListData)
{
rooms = roomListData.Rooms;
}
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);
}
}
