public async Task CreateRoom_ValidRequest_AddedToDatabase()
{
var request = new CreateRoomRequest()
{
Name = "Te",
ClubId = Guid.NewGuid()
};
using (var context = _factory.CreateContext())
{
context.Clubs.Add(new Club()
{
ClubId = request.ClubId
});
context.SaveChanges();
}
await _mutations.CreateRoomAsync(request);
using (var context = _factory.CreateContext())
{
var room = context.Rooms.FirstOrDefault(room => room.Name == request.Name);
Assert.That(room, Is.Not.Null);
Assert.That(context.Rooms.Count(), Is.EqualTo(1));
}
await _publish.Received(1).Publish(Arg.Any <RoomCreatedEvent>());
}
public override async Task <CreateRoomResponse> CreateNewRoom(CreateRoomRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new CreateRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
// Ensure max players is over 1
if (request.MaxPlayers < 2)
{
return new CreateRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
}
}
;
RedisRoomModel roomModel = new RedisRoomModel(request, user);
await roomModel.CreateInDatabase();
return(new CreateRoomResponse()
{
CreatedRoom = await roomModel.asRoom(),
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
/// <summary>
/// Creates a new room
/// </summary>
/// <returns>response containing id and link of the created room</returns>
/// <remarks>
/// Auth required with scope 'manage_rooms'. https://api.hipchat.com/v2/room
/// </remarks>
public HipchatCreateRoomResponse CreateRoom(CreateRoomRequest request)
{
using (JsonSerializerConfigScope())
{
if (request.Name.IsEmpty() || request.Name.Length > 50)
{
throw new ArgumentOutOfRangeException("request", "Name of room must be between 1 and 50 characters.");
}
try
{
return(HipchatEndpoints.CreateRoomEndpoint
.AddHipchatAuthentication()
.PostJsonToUrl(request)
.FromJson <HipchatCreateRoomResponse>());
}
catch (Exception exception)
{
if (exception is WebException)
{
throw ExceptionHelpers.WebExceptionHelper(exception as WebException, "manage_rooms");
}
throw ExceptionHelpers.GeneralExceptionHelper(exception, "CreateRoom");
}
}
}
private void CheckCreatingRoomParams(CreateRoomRequest createRoomInfo, ApplicationUser creater)
{
var errorcodes = new List <StatusCode>();
//TODO Искать только в видимых для пользователя комнатах
if (dataBase.Rooms.Any(R => R.Name == createRoomInfo.Name))
{
errorcodes.Add(StatusCode.RoomNameBusy);
}
if (creater.RoomId != null)
{
errorcodes.Add(StatusCode.PersonInRoomAtAWrongTime);
}
try { createRoomInfo.UsersCountMax = PeopleCount(createRoomInfo.UsersCountMax); }
catch (StatusCodeException ex) { errorcodes.Add(ex.StatusCode); }
catch { throw; }
switch (errorcodes.Count)
{
case 0: return;
case 1: throw new StatusCodeException(errorcodes[0]);
default:
throw new MultiStatusCodeException(errorcodes);
}
}
public async Task <ServiceResponse <CreateRoomViewModel> > CreateRoom(CreateRoomRequest request)
{
var player = await GetPlayer();
if (player == null)
{
return(ServiceResponse <CreateRoomViewModel> .Error("No user found"));
}
var isRoomNameValid = NamesValidator.IsNameValid(request.RoomName);
if (!isRoomNameValid)
{
return(ServiceResponse <CreateRoomViewModel> .Error("Room name is too short"));
}
var newRoom = new Room
{
Id = Guid.NewGuid(),
RoomName = request.RoomName,
PlayerMinCount = request.PlayerMinCount == 0 ? 2 : request.PlayerMinCount,
PlayerMaxCount = request.PlayerMaxCount
};
await _context.Rooms.AddAsync(newRoom);
player.RoomId = newRoom.Id;
_context.Update(player);
await _context.SaveChangesAsync();
return(ServiceResponse <CreateRoomViewModel> .Ok(new CreateRoomViewModel(newRoom)));
}
void Start()
{
//加载地图预览到地图数组
for (int i = 0; i < currentMapCount; i++)
{
mapArray.Add(new MapInfo(i, RoleType.None).MapSprite);
mapName.Add(new MapInfo(i, RoleType.None).MapName);
}
mapNameStr = transform.Find("Foreground/MapName").GetComponent <Text>();
map = transform.Find("Foreground/Map").GetComponent <Image>();
map.sprite = mapArray[currentMap];
mapNameStr.text = mapName[currentMap];
goLift = transform.Find("Foreground/GoLift").GetComponent <Button>();
goRight = transform.Find("Foreground/GoRight").GetComponent <Button>();
closeButton = transform.Find("Foreground/Close").GetComponent <Button>();
changeMapButton = transform.Find("Foreground/Map").GetComponent <Button>();
goLift.onClick.AddListener(OnGoLiftMapClick);
goRight.onClick.AddListener(OnGoRightMapClick);
closeButton.onClick.AddListener(OnCloseClick);
changeMapButton.onClick.AddListener(OnChangeMapClick);
createRoomRequest = GetComponent <CreateRoomRequest>();
}
public override bool SaveItem(bool copyCurrent = false)
{
var json = JsonView?.Text.ToString();
if (!string.IsNullOrEmpty(json))
{
try
{
var room = JsonConvert.DeserializeObject <Room>(json);
if (copyCurrent)
{
var roomRequest = new CreateRoomRequest(room.Name += "-copy");
STClient.CreateRoom(room.LocationId.ToString(), roomRequest);
}
else
{
var roomRequest = new UpdateRoomRequest(room.Name);
STClient.UpdateRoom(room.LocationId.ToString(), room.RoomId.ToString(), roomRequest);
}
RefreshScreen();
}
catch (SmartThingsNet.Client.ApiException exp)
{
ShowErrorMessage($"Error {exp.ErrorCode}{Environment.NewLine}{exp.Message}");
}
catch (Exception exp)
{
ShowErrorMessage($"Error {exp.Message}");
}
}
return(true);
}
public async Task <List <Room> > ParseRoomAsync(List <CreateRoomRequest> createRoomRequests)
{
List <Room> rooms = new List <Room>();
foreach (CreateRoomRequest createRoomRequest in createRoomRequests)
{
Room room = CreateRoomRequest.NewRoomFromRequest(createRoomRequest);
Param param = await _repoWrapper.Param.FindByIdAsync(createRoomRequest.RoomType);
if (param.Name == "Standard Room")
{
room.Capacity = 8;
}
else
{
room.Capacity = 4;
}
room.Price = param.DecimalValue.Value;
List <RoomTypesAndEquipmentTypes> roomTypesAndEquipmentTypes = (await _repoWrapper.RoomTypesAndEquipmentTypes.FindAllAsyncWithCondition(x => x.RoomTypeId == param.ParamId)).ToList();
foreach (RoomTypesAndEquipmentTypes roomTypesAndEquipmentType in roomTypesAndEquipmentTypes)
{
List <Equipment> equipments = (await _repoWrapper.Equipment.FindAllAsyncWithCondition(x => x.EquipmentTypeId == roomTypesAndEquipmentType.EquipmentTypeId && x.RoomId == null)).Take(roomTypesAndEquipmentType.Amount).ToList();
room.Equipments = equipments;
}
rooms.Add(room);
}
return(rooms);
}
protected async override Task OnInitializedAsync()
{
NewRoom = new CreateRoomRequest();
Carpet = await CarpetService.GetAllCarpetAsync();
Carpet = Carpet.OrderBy(c => c.Brand).ThenBy(c => c.Name).ToList();
}
public void PlayerWhoCreatesALobbyIsAMemberOfThatLobby()
{
var roomName = "My Room!";
var anon = false;
var isRanked = false;
var goal = Goal.Domination;
CreateRoomRequest createRequest = new CreateRoomRequest()
{
Anonymous = anon,
Goal = goal,
MaxPlayers = 5,
IsRanked = isRanked,
RoomName = roomName,
AllowedSpecialists = { "a", "b", "c" },
};
CreateRoomResponse roomResponse = client.CreateNewRoom(createRequest);
Assert.AreEqual(roomResponse.Status.IsSuccess, true);
var roomId = roomResponse.CreatedRoom.RoomId;
// 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].RoomId);
Assert.AreEqual(authHelper.getAccountId("userOne"), openLobbiesResponse.Rooms[0].Creator.Id);
Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Creator.Username);
Assert.AreEqual(1, openLobbiesResponse.Rooms[0].Players.Count);
Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Players[0].Username);
}
public CreateRoomResponse CreateRoom(CreateRoomRequest request)
{
CreateRoomResponse response = new CreateRoomResponse();
Room room = new Room();
room.RoomName = request.RoomName;
room.Address = request.Address;
room.PhoneNumber = request.PhoneNumber;
room.Users = request.Users.ConvertToUsers();
if (room.GetBrokenRules().Count() > 0)
{
response.Errors = room.GetBrokenRules().ToList();
}
else
{
try {
_roomRepository.Add(room);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
List <BusinessRule> errors = new List <BusinessRule>();
do
{
errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
ex = ex.InnerException;
} while (ex != null);
response.Errors = errors;
}
}
return(response);
}
public void CreateRoom(Room room, Action <Room> onSuccess = null, Action <string> onError = null)
{
room.Host.Value = api.LocalUser.Value;
var req = new CreateRoomRequest(room);
req.Success += result =>
{
joinedRoom = room;
update(room, result);
addRoom(room);
RoomsUpdated?.Invoke();
onSuccess?.Invoke(room);
};
req.Failure += exception =>
{
if (req.Result != null)
{
onError?.Invoke(req.Result.Error);
}
else
{
Logger.Log($"Failed to create the room: {exception}", level: LogLevel.Important);
}
};
api.Queue(req);
}
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 override async Task <CreateRoomResponse> CreateNewRoom(CreateRoomRequest request, ServerCallContext context)
{
DbUserModel dbUserModel = context.UserState["user"] as DbUserModel;
if (dbUserModel == null)
{
return new CreateRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
// Ensure max players is over 1
if (request.GameSettings.MaxPlayers < 2)
{
return new CreateRoomResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
}
}
;
Room room = new Room(request, dbUserModel.AsUser());
await room.CreateInDatabase();
return(new CreateRoomResponse()
{
CreatedRoom = room.GameConfiguration,
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
public static void CreateRoom()
{
using (Packet _packet = new Packet((int)PacketsCodes.createRoomCode))
{
print("Creating Room");
if (UIManager.instance.roomName.text == "" ||
UIManager.instance.maxPlayers.text == "" ||
UIManager.instance.questionCount.text == "" ||
UIManager.instance.answerTimeout.text == "" ||
!(1 <= int.Parse(UIManager.instance.maxPlayers.text) && int.Parse(UIManager.instance.maxPlayers.text) <= 999) ||
!(1 <= int.Parse(UIManager.instance.questionCount.text) && int.Parse(UIManager.instance.questionCount.text) <= 10) ||
!(1 <= int.Parse(UIManager.instance.answerTimeout.text) && int.Parse(UIManager.instance.answerTimeout.text) <= 99))
{
UIManager.instance.ShowError("Please check your inputs above", "createRoom");
return;
}
CreateRoomRequest request = new CreateRoomRequest();
request.roomName = UIManager.instance.roomName.text;
request.maxUsers = uint.Parse(UIManager.instance.maxPlayers.text);
request.questionCount = uint.Parse(UIManager.instance.questionCount.text);
request.answerTimeout = uint.Parse(UIManager.instance.answerTimeout.text);
string json = JsonUtility.ToJson(request);
_packet.Write(json.Length);
_packet.Write(json);
SendTCPData(_packet);
}
}
public RedisRoomModel(CreateRoomRequest request, RedisUserModel creator)
{
Guid roomId = Guid.NewGuid();
RoomModel = new RoomModel()
{
Anonymous = request.Anonymous,
CreatorId = creator.UserModel.Id,
Goal = request.Goal,
MaxPlayers = request.MaxPlayers,
RankedInformation = new RankedInformation()
{
IsRanked = request.IsRanked,
MinRating = 500,
MaxRating = 1500, // TODO: +-100 of user rank
},
RoomId = roomId.ToString(),
RoomName = request.RoomName,
RoomStatus = RoomStatus.Open,
Seed = new Random().Next(),
UnixTimeCreated = DateTime.UtcNow.ToFileTimeUtc(),
UnixTimeStarted = 0,
MinutesPerTick = request.MinutesPerTick,
};
RoomModel.AllowedSpecialists.AddRange(request.AllowedSpecialists);
GameTick.MINUTES_PER_TICK = RoomModel.MinutesPerTick;
}
// TODO? [Authorize]
public async Task CreateRoom(CreateRoomRequest request)
{
try
{
var room = await _roomService.CreateRoom(request.GameTypeID);
var response = _hubService.CreateGame(Context.ConnectionId, room, request);
if (response.GetType() == typeof(HubErrorResponse))
{
await SendErrorResponseToCaller((HubErrorResponse)response);
return;
}
var successResponse = (HubSuccessResponse)response;
var data = (CreateRoomResponse)successResponse.Data;
await Groups.AddToGroupAsync(Context.ConnectionId, data.Player.GroupName);
await SendSuccessResponseToCaller(successResponse);
}
catch (Exception ex)
{
await SendErrorResponseToCaller(new HubErrorResponse
{
Message = ex.Message,
Method = "CreateRoom"
});
}
}
private void createRoom()
{
var downloadComplete = game.DownloadGame(onlineGame);
Task.Run(async() =>
{
await downloadComplete.Task;
if (downloadComplete.Task.Result == false)
{
failure();
return;
}
var room = new CreateRoomRequest(onlineGame.Id);
room.Success += u =>
{
Schedule(() => LoadComponentAsync(new RoomScreen(u), this.Push));
};
room.Failure += ex =>
{
failure();
};
api.Queue(room);
void failure()
{
Schedule(() => infoOverlay.Show(@"Ocurrió un error al intentar crear la sala", Colour4.DarkRed));
}
});
}
public void ToApiCreateRoomRequest()
{
// ARRANGE
GroupMemberAcceptance paramGMA = GroupMemberAcceptance.AutoAllow;
string expectedGMAValue = "autoallow";
ApiCreateRoomRequest expected = FactoryRoom.ApiCreateRoomRequest;
expected.NewGroupMemberAcceptance = expectedGMAValue;
CreateRoomRequest param = new CreateRoomRequest(expected.Name)
{
ParentId = expected.ParentId.Value,
Quota = expected.Quota,
Notes = expected.Notes,
RecycleBinRetentionPeriod = expected.RecycleBinRetentionPeriod,
HasInheritPermissions = expected.InheritPermissions.Value,
AdminUserIds = expected.AdminIds,
AdminGroupIds = expected.AdminGroupIds,
NewGroupMemberAcceptance = paramGMA
};
Mock.Arrange(() => EnumConverter.ConvertGroupMemberAcceptanceToValue(paramGMA)).Returns(expectedGMAValue);
// ACT
ApiCreateRoomRequest actual = RoomMapper.ToApiCreateRoomRequest(param);
// ASSERT
Assert.Equal(expected, actual, new ApiCreateRoomRequestComparer());
}
public async Task <Room> CreateRoomAsync(string groupId, CreateRoomRequest request)
{
string url = _baseApiAddress + $"groups/{groupId}/rooms";
var content = new StringContent(JsonConvert.SerializeObject(request));
return(await HttpClient.PostAsync <Room>(url, content));
}
private void JoinRoom(string roomName, string zoneName)
{
var crr = new CreateRoomRequest {
RoomName = roomName, ZoneName = zoneName
};
_server.SendRequest(RequestTypes.CreateRoomRequest, crr, true);
}
public void CreateRoom()
{
CreateRoomRequest request = new CreateRoomRequest();
request.SendRequest();
CommonUtils.instance.SwitchViewMask(true);
}
public async Task <RoomResponse> Create(CreateRoomRequest model)
{
Room room = _mapper.Map <CreateRoomRequest, Room>(model);
await _roomRepository.Add(room);
RoomResponse response = _mapper.Map <Room, RoomResponse>(room);
return(response);
}
public void IfTheCreatorOfALobbyLeavesTheGameNoPlayersAreStuckInTheLobby()
{
CreateRoomRequest createRequest = new CreateRoomRequest()
{
Anonymous = false,
Goal = Goal.Domination,
MaxPlayers = 5,
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;
// Have a player join the game
authHelper.loginToAccount("userTwo");
client.JoinRoom(new JoinRoomRequest()
{
RoomId = roomId,
});
authHelper.loginToAccount("userOne");
// Have the host leave the lobby
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(0, openLobbiesResponsAfterLeave.Rooms.Count);
// Ensure the player is not in the game.
PlayerCurrentGamesResponse gamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());
Assert.AreEqual(gamesResponse.Status.IsSuccess, true);
Assert.AreEqual(0, gamesResponse.Games.Count);
authHelper.loginToAccount("userTwo");
// Ensure the player is not in the game.
PlayerCurrentGamesResponse gamesTwoResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());
Assert.AreEqual(gamesTwoResponse.Status.IsSuccess, true);
Assert.AreEqual(0, gamesTwoResponse.Games.Count);
}
public async Task <ChatRoom> CreateRoom(string roomName, CancellationToken token = default)
{
var operationToken = CancellationTokenSource.CreateLinkedTokenSource(clientLifetime.Token, token).Token;
var request = new CreateRoomRequest(roomName);
var response = await transport.Exchange <CreateRoomResponse>(request, operationToken);
return(response.Room);
}
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>();
}
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 static void CreateRoom()
{
List <long> roomAdminIds = new List <long> {
1
};
CreateRoomRequest request = new CreateRoomRequest("TestRoom", adminUserIds: roomAdminIds, notes: "It's a test room creation.");
Node createdRoomNode = dc.Nodes.CreateRoom(request);
Console.WriteLine("Created room id: " + createdRoomNode.Id + "; Name: " + createdRoomNode.Name);
}
void CreateRoom()
{
CreateRoomRequest createRoomRequest = new CreateRoomRequest();
AMsg aMsg = new AMsg()
{
Head = AMsg.Types.Head.CreateRoomRequest, CreateRoomRequest = createRoomRequest
};
byte[] byteArray = aMsg.ToByteArray();
WebSocketLoc.WebSocketUse.Send(byteArray);
}
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>();
}
/**
* Creates a CreateRoomRequest and sends to the server. If the room already exists the user will be joined to it.
*/
private void JoinRoom()
{
//request used to create a room
CreateRoomRequest crr = new CreateRoomRequest();
crr.RoomName = "UnityAvatarChat";
crr.ZoneName = "chat";
// create the plugin
PluginListEntry ple = new PluginListEntry();
ple.ExtensionName = EXTENSION_NAME;
ple.PluginHandle = PLUGIN_NAME;
ple.PluginName = PLUGIN_NAME;
List<PluginListEntry> pluginList = new List<PluginListEntry>();
pluginList.Add(ple);
crr.Plugins = pluginList;
// turn off events we don't need to reduce number of socket messages
crr.ReceivingRoomAttributeUpdates = false;
crr.ReceivingRoomListUpdates = false;
crr.ReceivingRoomVariableUpdates = false;
crr.ReceivingUserListUpdates = false; // will get these from the plugin
crr.ReceivingUserVariableUpdates = false;
crr.ReceivingVideoEvents = false;
// turn on the standard chat filtering
crr.UsingLanguageFilter = true;
crr.UsingFloodingFilter = true;
//send it
_es.Engine.Send(crr);
Log("CreateRoomRequest sent");
}
