// Called once the server registers the player right after the connection is established
public override void OnRegisterEvent()
{
print("Game Session received from server");
clog("Game Session received from server");
if (isInstructor)
{
EdgeManager.JoinOrCreateRoom("playerName", 0, 2);
//edgeManager.HandleWebSocketMessage("gameStart");
//EdgeManager.SendUDPMessage(new GamePlayEvent() { eventName = "Start" });
Debug.LogWarning("Game Start UDP Send");
}
else
{
Hashtable playertagsHashtable;
playertagsHashtable = null;
JoinRoomRequest joinRoomRequest = new JoinRoomRequest(roomId, "playerName" + Random.Range(0, 999), Random.Range(0, 999), playertagsHashtable);
EdgeManager.wsClient.Send(Messaging <JoinRoomRequest> .Serialize(joinRoomRequest));
}
//edgeManager.HandleWebSocketMessage("gameStart");
EdgeManager.GetAvailableRooms();
//EdgeManager.GetRooms();
}
public void PlayerCanJoinAGameRoom()
{
var roomId = createRoom();
authHelper.loginToAccount("userTwo");
// View open rooms.
OpenLobbiesResponse openLobbiesResponse = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponse.Status.IsSuccess, true);
Assert.AreEqual(1, openLobbiesResponse.Rooms.Count);
Assert.AreEqual(roomId, openLobbiesResponse.Rooms[0].Id);
// Ensure the creator is a member of the game
Assert.AreEqual(1, openLobbiesResponse.Rooms[0].Players.Count);
Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Players[0].Username);
JoinRoomRequest joinRequest = new JoinRoomRequest()
{
RoomId = roomId,
};
JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);
Assert.AreEqual(joinResponse.Status.IsSuccess, true);
OpenLobbiesResponse openLobbiesResponseAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponseAfterJoin.Status.IsSuccess, true);
Assert.AreEqual(1, openLobbiesResponseAfterJoin.Rooms.Count);
Assert.AreEqual(roomId, openLobbiesResponseAfterJoin.Rooms[0].Id);
Assert.AreEqual(2, openLobbiesResponseAfterJoin.Rooms[0].Players.Count);
Assert.IsTrue(openLobbiesResponseAfterJoin.Rooms[0].Players.Any(it => it.Id == authHelper.getAccountId("userTwo")));
}
public HttpResponseMessage Join([ModelBinder(typeof(JsonNetModelBinder))] JoinRoomRequest request)
{
var room = Data.FindRoom(request.GameName);
if (room == null)
{
var joinRoomFailedResponse = new JoinRoomResponse()
{
Result = false
};
return(new JsonNetResponseMessage(joinRoomFailedResponse));
}
var player = Data.FindPlayer(request.PlayerId);
if (player == null)
{
player = new Player()
{
Name = request.PlayerId,
RoomName = request.GameName
};
Data.Players.Add(player.Name, player);
}
room.Players.Add(player);
var response = new JoinRoomResponse()
{
Result = true,
Room = room
};
return(new JsonNetResponseMessage(response));
}
public void BeingTheLastPlayerToJoinAGameWillStartTheGame()
{
CreateRoomResponse roomResponse = client.CreateNewRoom(createRoomRequest("My room!", maxPlayers: 2));
Assert.AreEqual(roomResponse.Status.IsSuccess, true);
Assert.IsTrue(roomResponse.CreatedRoom.Id != null);
var roomId = roomResponse.CreatedRoom.Id;
authHelper.loginToAccount("userTwo");
JoinRoomRequest joinRequest = new JoinRoomRequest()
{
RoomId = roomId,
};
JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);
Assert.AreEqual(joinResponse.Status.IsSuccess, true);
// Check to see the room is not visible.
OpenLobbiesResponse openLobbiesResponseAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponseAfterJoin.Status.IsSuccess, true);
Assert.AreEqual(0, openLobbiesResponseAfterJoin.Rooms.Count);
// Check to see the player can see the game because they are a member.
PlayerCurrentGamesResponse playerGamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());
Assert.AreEqual(playerGamesResponse.Status.IsSuccess, true);
Assert.AreEqual(1, playerGamesResponse.Games.Count);
}
public override async Task <JoinRoomResponse> JoinRoom(JoinRoomRequest request, ServerCallContext context)
{
DbUserModel dbUserModel = context.UserState["user"] as DbUserModel;
if (dbUserModel == null)
{
return new JoinRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
Room room = await Room.GetRoomFromGuid(request.RoomId);
if (room == null)
{
return new JoinRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST)
}
}
;
return(new JoinRoomResponse()
{
Status = await room.JoinRoom(dbUserModel)
});
}
public void TryJoinRoom(IClient client, JoinRoomRequest data)
{
bool canJoin = ServerManager.Instance.Players.TryGetValue(client.ID, out var clientConnection);
if (!rooms.TryGetValue(data.RoomName, out var room))
{
canJoin = false;
}
else if (room.ClientConnections.Count >= room.MaxSlots)
{
canJoin = false;
}
if (canJoin)
{
room.AddPlayerToRoom(clientConnection);
}
else
{
using (Message m = Message.Create((ushort)Tags.LobbyJoinRoomDenied, new LobbyInfoData(GetRoomDataList())))
{
client.SendMessage(m, SendMode.Reliable);
}
}
}
void Client_JoinRomme(byte[] roomid)
{
JoinRoomRequest model_join_room = new JoinRoomRequest();
model_join_room.RoomId = roomid;
NetHelp.Send <JoinRoomRequest>(Op.Client.JoinRoom, model_join_room, Connection.Client.socket);
}
public void TryJoinRoom(IClient client, JoinRoomRequest data)
{
ClientConnection p;
Room r;
if (!ServerManager.Instance.Players.TryGetValue(client.ID, out p))
{
using (Message m = Message.Create((ushort)Tags.LobbyJoinRoomDenied, new LobbyInfoData(GetRoomDataList())))
{
client.SendMessage(m, SendMode.Reliable);
}
return;
}
if (!rooms.TryGetValue(data.RoomName, out r))
{
using (Message m = Message.Create((ushort)Tags.LobbyJoinRoomDenied, new LobbyInfoData(GetRoomDataList())))
{
client.SendMessage(m, SendMode.Reliable);
}
return;
}
if (r.ClientConnections.Count >= r.MaxSlots)
{
using (Message m = Message.Create((ushort)Tags.LobbyJoinRoomDenied, new LobbyInfoData(GetRoomDataList())))
{
client.SendMessage(m, SendMode.Reliable);
}
}
r.AddPlayerToRoom(p);
}
public void JoinRoomRequest_Instantiates_Properly(string room, bool isPrivate)
{
var a = new JoinRoomRequest(room, isPrivate);
Assert.Equal(room, a.RoomName);
Assert.Equal(isPrivate, a.IsPrivate);
}
public void PlayerCannotJoinAGameThatHasAlreadyStarted()
{
CreateRoomRequest createRequest = new CreateRoomRequest()
{
Anonymous = false,
Goal = Goal.Domination,
MaxPlayers = 2,
IsRanked = false,
RoomName = "My Room!",
AllowedSpecialists = { "a", "b", "c" },
};
CreateRoomResponse roomResponse = client.CreateNewRoom(createRequest);
Assert.AreEqual(roomResponse.Status.IsSuccess, true);
Assert.IsTrue(roomResponse.CreatedRoom.RoomId != null);
var roomId = roomResponse.CreatedRoom.RoomId;
authHelper.loginToAccount("userTwo");
JoinRoomRequest joinRequest = new JoinRoomRequest()
{
RoomId = roomId,
};
JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);
Assert.AreEqual(joinResponse.Status.IsSuccess, true);
authHelper.loginToAccount("userThree");
var exception = client.JoinRoom(joinRequest);
Assert.AreEqual(exception.Status.IsSuccess, false);
Assert.AreEqual(exception.Status.Detail, ResponseType.ROOM_IS_FULL.ToString());
}
public async Task <IRoom> JoinRoom(ChatRoom room, CancellationToken token = default)
{
var operationToken = CancellationTokenSource.CreateLinkedTokenSource(clientLifetime.Token, token).Token;
var chatRoom = new Room(this, room, transport);
if (!rooms.TryAdd(chatRoom.ChatRoom.Id, chatRoom))
{
throw new ChatException($"Cannot add room that already exists [room={chatRoom}]");
}
var request = new JoinRoomRequest(room.Id);
var response = await transport.Exchange <JoinRoomResponse>(request, operationToken);
foreach (var chatMessage in response.Messages)
{
if (!chatRoom.ReceiveMessage(chatMessage))
{
logger.LogWarning("Failed to deliver [message={Message}] to chat [room={Room}]",
chatMessage,
chatRoom);
}
}
return(chatRoom);
}
private void joinRoom(int id)
{
var downloadComplete = game.DownloadGame(onlineGame);
Task.Run(async() =>
{
await downloadComplete.Task;
if (downloadComplete.Task.Result == false)
{
failure();
return;
}
var joinRoom = new JoinRoomRequest(id);
joinRoom.Success += u =>
{
Schedule(() => LoadComponentAsync(new RoomScreen(u), this.Push));
};
joinRoom.Failure += ex =>
{
failure();
};
api.Queue(joinRoom);
void failure()
{
Schedule(() => infoOverlay.Show(@"Hubo un problema al intentar unirse a la sala", Colour4.DarkRed));
}
});
}
public async Task JoinRoom(JoinRoomRequest request)
{
try
{
var ctx = new ValidationContext(request);
var results = new List <ValidationResult>();
Validator.TryValidateObject(request, ctx, results, true);
if (results.Count > 0)
{
throw new ApplicationError("[JoinRoom]", 4);
}
var response = await _roomService.JoinRoom(request);
await Groups.AddToGroupAsync(Context.ConnectionId, response.roomIdentifier.ToString());
await Clients.Caller.JoinedRoom(response);
// do not broadcast all the messages for already joined users.
response.messages = null;
await Clients.OthersInGroup(response.roomIdentifier.ToString()).BrJoinedRoom(response);
}
catch (Exception e)
{
var errorResponse = ApplicationError.GetError <JoinRoomResponse>(e, "[JoinRoom]");
_logger.LogError(e.Message);
await Clients.Caller.JoinedRoom(errorResponse);
}
}
public async Task <HubResponse> JoinRoom(string connectionId, JoinRoomRequest joinRoomRequest)
{
if (string.IsNullOrWhiteSpace(joinRoomRequest.Name))
{
return(new HubErrorResponse {
Message = "Must enter a player name", Method = "JoinRoomAsClient", Title = "Validation Error"
});
}
var includeProperties = string.Join(",", "GameType");
var room = await _roomRepository.FirstOrDefault(e => e.RoomCode == joinRoomRequest.RoomCode, includeProperties);
var game = _games.FirstOrDefault(e => e.Key == room.RoomCode).Value;
var player = new Player
{
ConnectionId = connectionId,
Name = joinRoomRequest.Name,
RoomCode = joinRoomRequest.RoomCode,
GroupName = game.GroupName,
IsFirstPlayer = game.Players.Count() == 0
};
if (game.Players.Count < room.GameType.MaxPlayers)
{
if (game.Players.Any(e => e.Key == connectionId))
{
return(new HubErrorResponse {
Message = "Player is already connected.", Method = "JoinRoomAsClient"
});
}
game.Players.Add(connectionId, player);
_players.Add(connectionId, player);
}
else
{
// TODO: what to do with player joining if they are outside the max player count? add as spectator?
return(new HubErrorResponse {
Message = "Game is already full!", Method = "JoinRoomAsClient"
});
}
return(new HubSuccessResponse
{
Data = new JoinRoomResponse
{
ConnectionId = connectionId,
Description = room.GameType.Description,
GameName = room.GameType.GameName,
GroupName = game.GroupName,
Player = player,
MinPlayers = room.GameType.MinPlayers,
RoomCode = room.RoomCode
},
Message = "Joined!",
Method = "JoinRoomAsClient"
});
}
public void JoinRoom()
{
JoinRoomRequest request = new JoinRoomRequest();
request.SendRequest(this.Serial);
CommonUtils.instance.SwitchViewMask(true);
}
public override async Task <JoinRoomResponse> JoinRoom(JoinRoomRequest request,
ServerCallContext context)
{
string connectionId = context.GetHttpContext().Connection.Id;
// rooms[context.] = request.RoomId;
return(new JoinRoomResponse());
}
private void Awake()
{
Init();
UGUIEventListener.Get(CloseBtn).onClick = CloseRoomListPanelClick;
UGUIEventListener.Get(RefreshButton).onClick = RefreshButtonClick;
UGUIEventListener.Get(CreateRoomButton).onClick = CreateRoomButtonClick;
listRoomRequest = GetComponent <ListRoomRequest>();
createRoomRequestce = GetComponent <CreateRoomRequest>();
joinRoomRequest = GetComponent <JoinRoomRequest>();
}
/// <summary>
/// Hàm sẽ gửi lệnh Leave sau đó Send Messeage đến cho Server và đẩy lên server JoinRoomRequest
/// Ta sẽ viết hàm hứng OnAfterJoinRoom để xử lý khi join room thành công
/// </summary>
public void DoJoinRoom(int _zoneID, int _roomID)
{
Debug.Log("_zoneID " + _zoneID + " _roomID " + _roomID);
doJoiningRoom = new RoomInfo(_zoneID, _roomID);
JoinRoomRequest reqJoin = new JoinRoomRequest();
reqJoin.ZoneId = _zoneID;
reqJoin.RoomId = _roomID;
DoRequest(reqJoin);
}
public void PlayerCanLeaveAGameRoom()
{
CreateRoomResponse roomResponse = client.CreateNewRoom(createRoomRequest("My room!"));
Assert.AreEqual(roomResponse.Status.IsSuccess, true);
Assert.IsTrue(roomResponse.CreatedRoom.Id != null);
var roomId = roomResponse.CreatedRoom.Id;
authHelper.loginToAccount("userTwo");
// View open rooms.
OpenLobbiesResponse openLobbiesResponse = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponse.Status.IsSuccess, true);
Assert.AreEqual(1, openLobbiesResponse.Rooms.Count);
Assert.AreEqual(roomId, openLobbiesResponse.Rooms[0].Id);
// Ensure the creator is a member of the game
Assert.AreEqual(1, openLobbiesResponse.Rooms[0].Players.Count);
Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Players[0].Username);
JoinRoomRequest joinRequest = new JoinRoomRequest()
{
RoomId = roomId,
};
JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);
Assert.AreEqual(joinResponse.Status.IsSuccess, true);
// View open rooms.
OpenLobbiesResponse openLobbiesResponsAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponsAfterJoin.Status.IsSuccess, true);
Assert.AreEqual(1, openLobbiesResponsAfterJoin.Rooms.Count);
Assert.AreEqual(roomId, openLobbiesResponsAfterJoin.Rooms[0].Id);
Assert.AreEqual(2, openLobbiesResponsAfterJoin.Rooms[0].Players.Count);
LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
{
RoomId = roomId
};
LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);
Assert.AreEqual(leaveResponse.Status.IsSuccess, true);
// Ensure that the player has left the game.
// View open rooms.
OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponsAfterLeave.Status.IsSuccess, true);
Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms.Count);
Assert.AreEqual(roomId, openLobbiesResponsAfterLeave.Rooms[0].Id);
Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms[0].Players.Count);
}
public void JoinRoomRequest_Constructs_The_Correct_Message(string room)
{
var a = new JoinRoomRequest(room);
var msg = a.ToByteArray();
var reader = new MessageReader <MessageCode.Server>(msg);
var code = reader.ReadCode();
Assert.Equal(MessageCode.Server.JoinRoom, code);
Assert.Equal(room, reader.ReadString());
}
void Awake()
{
personalInfo = transform.Find("PersonalInfo").GetComponent <RectTransform>();
roomList = transform.Find("RoomList").GetComponent <RectTransform>();
roomLayout = transform.Find("RoomList/ScrollRect/Layout").GetComponent <VerticalLayoutGroup>();
roomItemPrefab = Resources.Load("UIPanel/RoomItem") as GameObject;
listRoomRequest = GetComponent <ListRoomRequest>();
createRoomRequest = GetComponent <CreateRoomRequest>();
joinRoomRequest = GetComponent <JoinRoomRequest>();
}
public void AdminsCanViewAnyOngoingGameTheyAreNotIn()
{
CreateRoomRequest createRequest = new CreateRoomRequest()
{
Anonymous = false,
Goal = Goal.Domination,
MaxPlayers = 2,
IsRanked = false,
RoomName = "My Room!",
AllowedSpecialists = { "a", "b", "c" },
};
CreateRoomResponse roomResponse = client.CreateNewRoom(createRequest);
Assert.AreEqual(roomResponse.Status.IsSuccess, true);
Assert.IsTrue(roomResponse.CreatedRoom.RoomId != null);
var roomId = roomResponse.CreatedRoom.RoomId;
authHelper.loginToAccount("userTwo");
JoinRoomRequest joinRequest = new JoinRoomRequest()
{
RoomId = roomId,
};
JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);
Assert.AreEqual(joinResponse.Status.IsSuccess, true);
// Check to see the room is not visible.
OpenLobbiesResponse openLobbiesResponseAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());
Assert.AreEqual(openLobbiesResponseAfterJoin.Status.IsSuccess, true);
Assert.AreEqual(0, openLobbiesResponseAfterJoin.Rooms.Count);
// Check to see the player can see the game because they are a member.
PlayerCurrentGamesResponse playerGamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());
Assert.AreEqual(playerGamesResponse.Status.IsSuccess, true);
Assert.AreEqual(1, playerGamesResponse.Games.Count);
SuperUser superUser = authHelper.CreateSuperUser();
client.Login(new AuthorizationRequest()
{
Password = superUser.password,
Username = superUser.userModel.UserModel.Username,
});
PlayerCurrentGamesResponse adminGamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());
Assert.AreEqual(adminGamesResponse.Status.IsSuccess, true);
Assert.AreEqual(1, adminGamesResponse.Games.Count);
}
private void Start()
{
transform.Find("RoomList/CloseButton").GetComponent <Button>().onClick.AddListener(OncloseBtnClick);
transform.Find("RoomList/CreateRoomButton").GetComponent <Button>().onClick.AddListener(OnCreateRoomBtnClick);
transform.Find("RoomList/RefreshButton").GetComponent <Button>().onClick.AddListener(OnRefreshBtnClick);
roomLayout = transform.Find("RoomList/ScrollRect/Layout").GetComponent <VerticalLayoutGroup>();
roomItemPrefab = Resources.Load("UIPanel/Room") as GameObject;
listRoomRequest = GetComponent <ListRoomRequest>();
createRoomRequest = GetComponent <CreateRoomRequest>();
joinRoomRequest = GetComponent <JoinRoomRequest>();
}
public async Task UpdateUser(JoinRoomRequest updated)
{
var userQuery = db.Users.Where(u => u.ConnectionId == Context.ConnectionId);
var user = await userQuery.FirstOrDefaultAsync();
user.DisplayName = updated.Name;
user.EmblemId = updated.EmblemId;
await db.SaveChangesAsync();
var roomId = user?.RoomId;
await Clients.Group(roomId).SendAsync("UserUpdated", new ListChange <User>(user, await GetRoomUsers(roomId)));
}
public async ValueTask ExecuteAsync(JoinRoomCommand command)
{
var request = new JoinRoomRequest
{
SessionId = command.SessionId,
Room = command.Room
};
await m_MessageQueueService.RequestAsync(
"room.join",
request.ToByteArray()).ConfigureAwait(false);
}
void Start()
{
//初始化组件
_listRoomRequest = this.GetComponent <ListRoomRequest>();
_joinRoomRequest = this.GetComponent <JoinRoomRequest>();
_canvasGroup = this.GetComponent <CanvasGroup>();
_layout = this.transform.Find("Img_RoomListBG/Img_List/Emt_Layout");
//按钮注册监听点击事件
closeBtn.onClick.AddListener(delegate() { CloseButtonClicked(); });
creatRoomBtn.onClick.AddListener(delegate() { CreatRoomButtonClicked(); });
reflashRoomListBtn.onClick.AddListener(delegate() { ReFlashRoomListButtonClicked(); });
}
public IActionResult JoinRoom()
{
var RoomId = HttpContext.Request.Query["room_id"].ToString();
var UserId = HttpContext.Request.Query["user_id"].ToString();
var Email = HttpContext.Request.Query["email"].ToString();
var FullName = HttpContext.Request.Query["fullname"].ToString();
var Mssv = HttpContext.Request.Query["mssv"].ToString();
JoinRoomRequest joinRoomRequest = null;
if (RoomId.Equals(""))
{
Response.StatusCode = 401;
return(Ok(new ApiResultErrors <string>()
{
Message = "Vào phòng thất bại!"
}));
}
else if (!UserId.Equals(""))
{
joinRoomRequest = new JoinRoomRequest()
{
RoomId = int.Parse(RoomId),
UserId = int.Parse(UserId),
};
}
else
{
joinRoomRequest = new JoinRoomRequest()
{
RoomId = int.Parse(RoomId),
Mssv = Mssv,
Email = Email,
FullName = FullName
};
}
var data = _roomService.JoinRoom(joinRoomRequest);
if (data == null)
{
Response.StatusCode = 401;
return(Ok(new ApiResultErrors <string>()
{
Message = "Vào phòng thất bại!"
}));
}
else
{
return(new JsonResult(data));
}
}
/**
* Join a room with it's identifier.
* If the room does not exist create it
* otherwise join.
*/
public async Task <JoinRoomResponse> JoinRoom(JoinRoomRequest payload)
{
try
{
var response = new JoinRoomResponse();
User user = await _userRepository.FindRoomOfUserById((Guid)payload.userIdentifier);
if (user == null)
{
throw new ApplicationError("[RoomService.JoinRoom]", 1);
}
var room = await _roomRepository.FindByIdentifier((Guid)payload.roomIdentifier);
if (room == null)
{
room = new Room();
room.id = Guid.NewGuid();
room.identifier = (Guid)payload.roomIdentifier;
room.users = new List <User> {
user
};
bool result = await _roomRepository.Save(room);
if (!result)
{
throw new ApplicationError("[RoomService.JoinRoom]", 3);
}
}
else
{
room.users = await _userRepository.FindAllByRoomId(room.id);
room.users.Add(user);
}
response.roomIdentifier = room.identifier;
response.users = room.users;
response.messages = await _messageRepository.FindAllByRoomId(room.id);
await _unitOfWork.Save();
return(response);
}
catch (Exception e)
{
throw e;
}
}
public void JoinRoom(string room)
{
var content = new JoinRoomRequest()
{
UID = room
};
Emit("join-room", content);
socket.On("room-joined", (data) =>
{
isConnected = true;
Console.WriteLine("Joined room on the server: " + data.ToString());
});
}
void Start()
{
roomItemPrefab = Resources.Load("UIPanel/RoomItem") as GameObject;
battleRes = transform.Find("BattleRes").GetComponent <RectTransform>();
roomList = transform.Find("RoomList").GetComponent <RectTransform>();
transform.Find("RoomList/CloseButton").GetComponent <Button>().onClick.AddListener(OnCloseClick);
roomLayout = transform.Find("RoomList/ScrollRect/Layout").GetComponent <VerticalLayoutGroup>();
transform.Find("RoomList/CreateRoomButton").GetComponent <Button>().onClick.AddListener(OnCreateRoomClick);
transform.Find("RoomList/RefreshButton").GetComponent <Button>().onClick.AddListener(OnRefreshClick);
listRoomRequest = GetComponent <ListRoomRequest>();
crRequest = GetComponent <CreateRoomRequest>();
joinRoomRequest = GetComponent <JoinRoomRequest>();
EnterAnim();
}
public void JoinRoom()
{
_form.tabRooms.SelectedTab = this;
JoinRoomRequest j = new JoinRoomRequest(_occupant);
_sm.SendAndForget(j);
}
private void OnLogin(BaseEvent evt) {
User user = (Sfs2X.Entities.User)evt.Params["user"];
trace("Login successful");
trace("Username is: " + user.Name);
// Now we want to send z_l to the server
SFSObject sfsObj = new SFSObject();
// Set our current version
sfsObj.PutUtfString("V","3D1");
sfsObj.PutInt("ID",Convert.ToInt32(user.Name));
// Get the login info for this user
this.sendMessage("l",sfsObj);
// Enable lag monitor
JoinRoomRequest jr = new JoinRoomRequest("lobby");
this.sfs.Send(jr);
}
