public async Task <List <RedisUserModel> > GetPlayersInGame()
{
List <RedisUserModel> players = new List <RedisUserModel>();
RedisValue[] playerIds = await RedisConnector.Redis.SetMembersAsync(GameRoomPlayerListKey());
foreach (var playerId in playerIds)
{
players.Add(await RedisUserModel.GetUserFromGuid(playerId));
}
return(players);
}
public async Task <Boolean> CreateInDatabase()
{
HashEntry[] roomRecord =
{
new HashEntry(RoomModel.RoomId, RoomModel.ToByteArray()),
};
await RedisConnector.Redis.HashSetAsync(GameRoomsHashKey(), roomRecord);
if (RoomModel.RoomStatus == RoomStatus.Open)
{
await RedisConnector.Redis.SetAddAsync(OpenLobbiesKey(), RoomModel.RoomId);
}
// Add the creator as a player in the game
await JoinRoom(await RedisUserModel.GetUserFromGuid(RoomModel.CreatorId));
return(true);
}
public async Task <Room> asRoom()
{
// TODO: If the room is anonymous, hide the creator and player ids.
Room room = new Room()
{
RoomId = RoomModel.RoomId,
RoomStatus = RoomModel.RoomStatus,
Creator = (await RedisUserModel.GetUserFromGuid(RoomModel.CreatorId)).asUser(),
RankedInformation = RoomModel.RankedInformation,
Anonymous = RoomModel.Anonymous,
RoomName = RoomModel.RoomName,
Goal = RoomModel.Goal,
Seed = RoomModel.Seed,
UnixTimeCreated = RoomModel.UnixTimeCreated,
UnixTimeStarted = RoomModel.UnixTimeStarted,
MaxPlayers = RoomModel.MaxPlayers,
MinutesPerTick = RoomModel.MinutesPerTick,
};
List <RedisUserModel> playersInGame = await GetPlayersInGame();
room.Players.AddRange(playersInGame.ConvertAll(it => it.asUser()));
room.AllowedSpecialists.AddRange(RoomModel.AllowedSpecialists);
return(room);
}
public async Task <CreateMessageGroupResponse> CreateMessageGroup(List <String> groupMembers)
{
// Sort member list by id
groupMembers.Sort((a, b) => String.Compare(a, b, StringComparison.Ordinal));
// Get group hash
string hash = "";
foreach (var userId in groupMembers)
{
RedisUserModel user = await RedisUserModel.GetUserFromGuid(userId);
if (user == null)
{
return new CreateMessageGroupResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST),
}
}
;
// Ensure the user is in the game room.
if (await IsPlayerInRoom(user))
{
hash += user.UserModel.Username;
}
else
{
return(new CreateMessageGroupResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED),
});
}
}
// Determine if the Id exists.
if (await RedisConnector.Redis.HashExistsAsync(GameRoomChatListKey(), hash))
{
return(new CreateMessageGroupResponse()
{
Status = ResponseFactory.createResponse(ResponseType.DUPLICATE),
});;
}
// Create the group
GroupModel newGroup = new GroupModel();
newGroup.GroupId = hash;
foreach (string s in groupMembers)
{
RedisUserModel model = await RedisUserModel.GetUserFromGuid(s);
if (model != null)
{
newGroup.GroupMembers.Add(model.asUser());
}
}
await RedisConnector.Redis.HashSetAsync(GameRoomChatListKey(), hash, newGroup.ToByteArray());
return(new CreateMessageGroupResponse()
{
GroupId = hash,
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
