public async Task <ResponseStatus> LeaveRoom(RedisUserModel userModel)
{
if (RoomModel.RoomStatus == RoomStatus.Open)
{
// Check if the player leaving was the host.
if (RoomModel.CreatorId == userModel.UserModel.Id)
{
// Remove all players from the game.
foreach (var player in await GetPlayersInGame())
{
// Make sure we don't infinitely loop.
if (player.UserModel.Id != RoomModel.CreatorId)
{
await LeaveRoom(player);
}
}
// Destroy room.
await RedisConnector.Redis.HashDeleteAsync(GameRoomsHashKey(), RoomModel.RoomId);
await RedisConnector.Redis.SetRemoveAsync(OpenLobbiesKey(), RoomModel.RoomId);
// Finally, remove creator from game
await RedisConnector.Redis.SetRemoveAsync(GameRoomPlayerListKey(), userModel.UserModel.Id);
await RedisConnector.Redis.SetRemoveAsync(UserGameListKey(userModel), RoomModel.RoomId);
return(ResponseFactory.createResponse(ResponseType.SUCCESS));
}
await RedisConnector.Redis.SetRemoveAsync(GameRoomPlayerListKey(), userModel.UserModel.Id);
await RedisConnector.Redis.SetRemoveAsync(UserGameListKey(userModel), RoomModel.RoomId);
return(ResponseFactory.createResponse(ResponseType.SUCCESS));
}
// TODO: Player left the game while ongoing.
// Create a player leave game event and push to event list
return(ResponseFactory.createResponse(ResponseType.INVALID_REQUEST));
}
public async Task <ResponseStatus> JoinRoom(RedisUserModel userModel)
{
List <RedisUserModel> playersInRoom = await GetPlayersInGame();
if (playersInRoom.Count >= RoomModel.MaxPlayers)
{
return(ResponseFactory.createResponse(ResponseType.ROOM_IS_FULL));
}
if (playersInRoom.Any(it => it.UserModel.Id == userModel.UserModel.Id))
{
return(ResponseFactory.createResponse(ResponseType.DUPLICATE));
}
if (RoomModel.RoomStatus != RoomStatus.Open)
{
return(ResponseFactory.createResponse(ResponseType.GAME_ALREADY_STARTED));
}
// Check if any players in the room have the same device identifier
if (playersInRoom.Any(it => it.UserModel.DeviceIdentifier == userModel.UserModel.DeviceIdentifier))
{
return(ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED));
}
await RedisConnector.Redis.SetAddAsync(GameRoomPlayerListKey(), userModel.UserModel.Id);
await RedisConnector.Redis.SetAddAsync(UserGameListKey(userModel), RoomModel.RoomId);
// Check if the player joining the game is the last player.
if (playersInRoom.Count + 1 == RoomModel.MaxPlayers)
{
return(await StartGame());
}
return(ResponseFactory.createResponse(ResponseType.SUCCESS));;
}
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 <List <GroupChatModel> > GetPlayerGroupChats(RedisUserModel user)
{
// Get all group chats
List <GroupChatModel> groupChatList = new List <GroupChatModel>();
HashEntry[] groupChats = await RedisConnector.Redis.HashGetAllAsync(GameRoomChatListKey());
foreach (var groupChat in groupChats)
{
GroupChatModel model = new GroupChatModel(this, groupChat.Value);
// Admins can see all group chats.
if (user.HasClaim(UserClaim.Admin))
{
groupChatList.Add(model);
}
else if (model.IsPlayerInGroup(user))
{
groupChatList.Add(model);
}
}
return(groupChatList);
}
public SuperUser(RedisUserModel user, string password)
{
this.userModel = user;
this.password = password;
}
public Boolean IsPlayerInGroup(RedisUserModel user)
{
return(MessageGroup.GroupMembers.Any(it => it.Id == user.UserModel.Id));
}
public async Task <Boolean> IsPlayerInRoom(RedisUserModel player)
{
return((await GetPlayersInGame()).Any(it => it.UserModel.Id == player.UserModel.Id));
}
private string UserGameListKey(RedisUserModel user)
{
return($"users:{user.UserModel.Id}:games");
}
private string UserGameEventsKey(RedisUserModel user)
{
return($"game:{RoomModel.RoomId}:user:{user.UserModel.Id}:events");
}
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),
});
}
public async Task <bool> IsFriend(RedisUserModel friend)
{
return(await RedisConnector.Redis.SetContainsAsync($"user:{UserModel.Id}:friends", friend.UserModel.Id));
}
public async Task <ResponseStatus> RemoveFriendRequestFrom(RedisUserModel requestingUser)
{
await RedisConnector.Redis.SetRemoveAsync($"user:{UserModel.Id}:friendRequests", requestingUser.UserModel.Id);
return(ResponseFactory.createResponse(ResponseType.SUCCESS));
}
public async Task <bool> IsBlocked(RedisUserModel otherUser)
{
return(await RedisConnector.Redis.SetContainsAsync($"user:{UserModel.Id}:blocks", otherUser.UserModel.Id));
}
