Marco Baldwin
458 lines
20 KiB
C#
458 lines
20 KiB
C#
using DeluxeBackend.Controllers.Auth;
|
|
using DeluxeBackend.Models;
|
|
using DeluxeBackend.Services;
|
|
using Discord;
|
|
using Discord.Net;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using static DeluxeBackend.Enums;
|
|
|
|
namespace DeluxeBackend.Controllers.Matchmaking
|
|
{
|
|
[Token(Token = "0x2000BB7")]
|
|
public enum PLBMBHKLCHD
|
|
{
|
|
[Token(Token = "0x4002DF5")] UnknownError = -1,
|
|
[Token(Token = "0x4002DF6")] Success,
|
|
[Token(Token = "0x4002DF7")] NoSuchGame,
|
|
[Token(Token = "0x4002DF8")] PlayerNotOnline,
|
|
[Token(Token = "0x4002DF9")] InsufficientSpace,
|
|
[Token(Token = "0x4002DFA")] EventNotStarted,
|
|
[Token(Token = "0x4002DFB")] EventAlreadyFinished,
|
|
[Token(Token = "0x4002DFC")] BlockedFromRoom = 7,
|
|
[Token(Token = "0x4002DFD")] JuniorNotAllowed = 11,
|
|
[Token(Token = "0x4002DFE")] Banned,
|
|
[Token(Token = "0x4002DFF")] AlreadyInBestInstance,
|
|
[Token(Token = "0x4002E00")] InsufficientRelationship,
|
|
[Token(Token = "0x4002E01")] UpdateRequired = 16,
|
|
[Token(Token = "0x4002E02")] AlreadyInTargetInstance,
|
|
[Token(Token = "0x4002E03")] UGCNotAllowed = 19,
|
|
[Token(Token = "0x4002E04")] NoSuchRoom,
|
|
[Token(Token = "0x4002E05")] RoomIsNotActive = 22,
|
|
[Token(Token = "0x4002E06")] RoomBlockedByCreator,
|
|
[Token(Token = "0x4002E07")] RoomIsPrivate = 25,
|
|
[Token(Token = "0x4002E08")] RoomInstanceIsPrivate,
|
|
[Token(Token = "0x4002E09")] DeviceClassNotSupported = 30,
|
|
[Token(Token = "0x4002E0A")] DeviceClassNotSupportedByRoomOwner,
|
|
[Token(Token = "0x4002E0B")] MovementModeNotSupportedByRoomOwner,
|
|
[Token(Token = "0x4002E0C")] EventIsPrivate = 35,
|
|
[Token(Token = "0x4002E0D")] EventIsFull,
|
|
[Token(Token = "0x4002E0E")] RoomInviteExpired = 40,
|
|
[Token(Token = "0x4002E0F")] NoAvailableRegion = 45,
|
|
[Token(Token = "0x4002E10")] NotorietyTooPoor = 50,
|
|
[Token(Token = "0x4002E11")] BannedFromRoom = 55,
|
|
[Token(Token = "0x4002E12")] NoSuchClub = 70,
|
|
[Token(Token = "0x4002E13")] ClubHasNoClubhouse,
|
|
[Token(Token = "0x4002E14")] ClubIsNotActive = 73,
|
|
[Token(Token = "0x4002E15")] NotAMemberOfClub,
|
|
[Token(Token = "0x4002E16")] BannedFromClub,
|
|
[Token(Token = "0x4002E17")] InstanceJoinNotPermitted,
|
|
[Token(Token = "0x4002E18")] LevelTooLow,
|
|
[Token(Token = "0x4002E19")] ChatPartyInviteNotFound,
|
|
[Token(Token = "0x4002E1A")] ChatPartyInviteModerated,
|
|
[Token(Token = "0x4002E1B")] ChatMessageNotAnInvite,
|
|
[Token(Token = "0x4002E1C")] DeveloperOnly,
|
|
[Token(Token = "0x4002E1D")] RRPlusRequired,
|
|
[Token(Token = "0x4002E1F")] MetaJuniorAccountRestriction,
|
|
[Token(Token = "0x4002E1F")] NotExclusivelyLoggedIn,
|
|
[Token(Token = "0x4002E20")] AccountDoesNotExist
|
|
}
|
|
|
|
public enum JoinType
|
|
{
|
|
[Token(Token = "0x4002DF1")] PublicMatchmaking,
|
|
[Token(Token = "0x4002DF2")] PublicNewInstance,
|
|
[Token(Token = "0x4002DF3")] PrivateNewInstance
|
|
}
|
|
|
|
public class JoinRoomRequestDto
|
|
{
|
|
[Required] public bool BypassMovementModeRestriction { get; set; }
|
|
[Required] public int MaxPersistenceVersion { get; set; }
|
|
[Required] public JoinType JoinMode { get; set; }
|
|
public string? ClientJoinData { get; set; }
|
|
}
|
|
|
|
[Route("Matchmaking/matchmake")]
|
|
[ApiController]
|
|
[Authorize(Roles = "gameClient")]
|
|
public class MatchmakeController(IJwtService jwt, ILiteDbService db, INotificationService ws) : ControllerBase
|
|
{
|
|
private static readonly object _statsLock = new();
|
|
|
|
[HttpPost("none")]
|
|
public async Task<IActionResult> None()
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var presence = GetOrCreatePresence(login.Account);
|
|
presence.Instance = null;
|
|
presence.AppVersion = login.AppVersion;
|
|
|
|
await SaveAndNotifyPresenceAsync(presence);
|
|
return Ok(presence.ToDictionary());
|
|
}
|
|
|
|
[HttpPost("dorm")]
|
|
public async Task<IActionResult> Dorm([FromForm, Required] JoinRoomRequestDto request)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var account = login.Account;
|
|
var presence = GetOrCreatePresence(account);
|
|
|
|
var room = db.Rooms.Include(x => x.Creator).FindOne(x => x.IsDorm == true && x.Creator.Id == account.Id);
|
|
if (room == null)
|
|
{
|
|
var baseDorm = db.Rooms.Include(x => x.Creator).FindOne(x => x.IsDorm == true && x.Creator.Id == 1);
|
|
if (baseDorm == null)
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomIsNotActive });
|
|
}
|
|
|
|
room = InitializeNewDormRoom(account, baseDorm);
|
|
db.Rooms.Insert(room);
|
|
CloneSubRooms(room, baseDorm, account, login);
|
|
}
|
|
|
|
if (room.Accessibility == RoomAccessibility.Private && !room.HasRole(account.Id, RoomRoleType.CoOwner))
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomIsPrivate });
|
|
}
|
|
|
|
var subRooms = db.SubRooms.Include(x => x.Room).Find(x => x.Room.Id == room.Id && x.CanMatchmakeInto).ToList();
|
|
if (subRooms.Count == 0)
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.DeveloperOnly });
|
|
}
|
|
|
|
var subRoom = subRooms[Random.Shared.Next(subRooms.Count)];
|
|
var privateInstances = db.RoomInstances
|
|
.Include(x => x.SubRoom)
|
|
.Include(x => x.SubRoom!.Room)
|
|
.Include(x => x.SubRoom!.Room!.Creator)
|
|
.Find(x => x.SubRoom.Id == subRoom.Id && x.InstanceType == Enums.RoomInstanceType.Dormroom && x.EventId == -1)
|
|
.ToList();
|
|
|
|
var roomInstance = privateInstances.Count == 0
|
|
? CreateNewInstance(subRoom, Enums.RoomInstanceType.Dormroom, true)
|
|
: privateInstances[0];
|
|
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, room, login.AppVersion);
|
|
}
|
|
|
|
[HttpPost("room/{RoomId}")]
|
|
public async Task<IActionResult> GoToRoom([FromRoute] long RoomId, [FromForm, Required] JoinRoomRequestDto request)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
var room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Id == RoomId);
|
|
if (RoomId == 3 && DateTime.UtcNow.Month == 6)
|
|
{
|
|
room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Name == "PrideCenter");
|
|
}
|
|
if (room == null) return Ok(new { errorCode = PLBMBHKLCHD.NoSuchRoom });
|
|
|
|
var account = login.Account;
|
|
if (room.Accessibility == RoomAccessibility.Private && !room.HasRole(account.Id, RoomRoleType.CoOwner))
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomIsPrivate });
|
|
}
|
|
|
|
var subRooms = db.SubRooms.Include(x => x.Room).Find(x => x.Room.Id == room.Id && x.CanMatchmakeInto).ToList();
|
|
if (subRooms.Count == 0) return Ok(new { errorCode = PLBMBHKLCHD.DeveloperOnly });
|
|
|
|
var subRoom = subRooms[Random.Shared.Next(subRooms.Count)];
|
|
var presence = GetOrCreatePresence(account);
|
|
|
|
var roomInstance = ResolveRoomInstance(subRoom, room.Accessibility, request.JoinMode);
|
|
if (roomInstance == null) return Ok(new { errorCode = PLBMBHKLCHD.NoAvailableRegion });
|
|
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, room, login.AppVersion);
|
|
}
|
|
|
|
[HttpPost("room/{RoomId}/{SubRoomId}")]
|
|
public async Task<IActionResult> GoToSubRoom([FromRoute] long RoomId, [FromRoute] long SubRoomId, [FromForm, Required] JoinRoomRequestDto request)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Id == RoomId);
|
|
if (RoomId == 3 && DateTime.UtcNow.Month == 6)
|
|
{
|
|
room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Name == "PrideCenter");
|
|
}
|
|
if (room == null) return Ok(new { errorCode = PLBMBHKLCHD.NoSuchRoom });
|
|
|
|
var account = login.Account;
|
|
if (room.Accessibility == RoomAccessibility.Private && !room.HasRole(account.Id, RoomRoleType.CoOwner))
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomIsPrivate });
|
|
}
|
|
|
|
var subRoom = db.SubRooms.Include(x => x.Room).FindOne(x => x.Room.Id == room.Id && x.Id == SubRoomId);
|
|
if (subRoom == null) return Ok(new { errorCode = PLBMBHKLCHD.NoSuchGame });
|
|
|
|
var presence = GetOrCreatePresence(account);
|
|
|
|
var roomInstance = ResolveRoomInstance(subRoom, room.Accessibility, request.JoinMode);
|
|
if (roomInstance == null) return Ok(new { errorCode = PLBMBHKLCHD.NoAvailableRegion });
|
|
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, room, login.AppVersion);
|
|
}
|
|
|
|
[HttpPost("event/{EventId}")]
|
|
public async Task<IActionResult> GoToEvent([FromRoute] long EventId, [FromForm, Required] JoinRoomRequestDto request)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var playerEvent = db.PlayerEvents.Include(x => x.Room).Include(x => x.SubRoom).Include(x => x.Creator).FindById(EventId);
|
|
if (playerEvent == null) return NotFound();
|
|
|
|
var room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Id == playerEvent.Room.Id);
|
|
if (room == null) return Ok(new { errorCode = PLBMBHKLCHD.NoSuchRoom });
|
|
|
|
var account = login.Account;
|
|
if (room.Accessibility == RoomAccessibility.Private && !room.HasRole(account.Id, RoomRoleType.CoOwner))
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomIsPrivate });
|
|
}
|
|
|
|
var subRoom = db.SubRooms.Include(x => x.Room).FindOne(x => x.Room.Id == room.Id && x.Id == playerEvent.SubRoom.Id);
|
|
if (subRoom == null) return Ok(new { errorCode = PLBMBHKLCHD.NoSuchGame });
|
|
|
|
RoomInstance? roomInstance = null;
|
|
if (playerEvent.IsMultiInstance)
|
|
{
|
|
var roomInstances = db.RoomInstances.Include(x => x.SubRoom)
|
|
.Find(x => x.SubRoom.Id == playerEvent.SubRoom.Id && x.Id != playerEvent.BroadcastingRoomInstanceId && x.EventId == playerEvent.Id && !x.Private).ToList();
|
|
|
|
roomInstance = roomInstances.Count == 0
|
|
? CreateNewInstance(subRoom, Enums.RoomInstanceType.MultiInstanceEvent, false, EventId)
|
|
: roomInstances[Random.Shared.Next(roomInstances.Count)];
|
|
}
|
|
|
|
if (roomInstance == null) return Ok(new { errorCode = PLBMBHKLCHD.NoAvailableRegion });
|
|
|
|
var presence = GetOrCreatePresence(account);
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, room, login.AppVersion);
|
|
}
|
|
|
|
[HttpPost("invite/{InviteId}")]
|
|
public async Task<IActionResult> GoToInvite([FromRoute] long InviteId)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var account = login.Account;
|
|
var playerInvite = db.PlayerInvites.FindById(InviteId);
|
|
|
|
if (playerInvite == null || playerInvite.Account.Id != account.Id || !playerInvite.IsValid)
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.RoomInviteExpired });
|
|
}
|
|
|
|
var roomInstance = db.RoomInstances.Include(x => x.SubRoom).Include(x => x.SubRoom!.Room).Include(x => x.SubRoom!.Room!.Creator).FindById(playerInvite.InstanceId);
|
|
if (roomInstance == null) return Ok(new { errorCode = PLBMBHKLCHD.NoAvailableRegion });
|
|
|
|
var presence = GetOrCreatePresence(account);
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, roomInstance.SubRoom.Room, login.AppVersion);
|
|
}
|
|
|
|
[HttpPost("instance/{instanceId}")]
|
|
public async Task<IActionResult> GoToInstance([FromRoute] long instanceId)
|
|
{
|
|
var login = await jwt.GetLoginWithInfo(User);
|
|
if (login == null) return Unauthorized();
|
|
|
|
var roomInstance = db.RoomInstances.Include(x => x.SubRoom).Include(x => x.SubRoom!.Room).Include(x => x.SubRoom!.Room!.Creator).FindById(instanceId);
|
|
if (roomInstance == null) return NotFound();
|
|
if (roomInstance.Private) return Ok(new { errorCode = PLBMBHKLCHD.RoomInstanceIsPrivate });
|
|
|
|
var account = login.Account;
|
|
var presence = GetOrCreatePresence(account);
|
|
return await ProcessPresenceTransitionAsync(presence, roomInstance, account, roomInstance.SubRoom.Room, login.AppVersion);
|
|
}
|
|
|
|
#region Helpers
|
|
|
|
private AccountPresence GetOrCreatePresence(Account account)
|
|
{
|
|
var presence = db.Presences
|
|
.Include(x => x.Account)
|
|
.Include(x => x.Instance)
|
|
.Include(x => x.Instance!.SubRoom)
|
|
.Include(x => x.Instance!.SubRoom!.Room)
|
|
.Include(x => x.Instance!.SubRoom!.Room!.Creator)
|
|
.FindOne(x => x.Account.Id == account.Id);
|
|
|
|
return presence ?? new AccountPresence { Account = account };
|
|
}
|
|
|
|
private async Task SaveAndNotifyPresenceAsync(AccountPresence presence)
|
|
{
|
|
presence.LastOnline = DateTime.UtcNow;
|
|
presence.IsOnline = true;
|
|
db.Presences.Upsert(presence);
|
|
await ws.SendToAllPlayer("PresenceUpdate", presence.ToDictionary());
|
|
}
|
|
|
|
private RoomInstance CreateNewInstance(SubRoom subRoom, RoomInstanceType type, bool isPrivate, long eventId = -1)
|
|
{
|
|
var instance = new RoomInstance
|
|
{
|
|
SubRoom = subRoom,
|
|
InstanceType = type,
|
|
Private = isPrivate,
|
|
PhotonRegion = "eu",
|
|
PhotonRoom = Guid.NewGuid().ToString(),
|
|
EventId = eventId,
|
|
CreatedAt = DateTime.UtcNow
|
|
};
|
|
db.RoomInstances.Insert(instance);
|
|
return instance;
|
|
}
|
|
|
|
private RoomInstance? ResolveRoomInstance(SubRoom subRoom, RoomAccessibility accessibility, JoinType joinMode)
|
|
{
|
|
if (accessibility == RoomAccessibility.Private)
|
|
{
|
|
var privateInstances = db.RoomInstances.Include(x => x.SubRoom).Include(x => x.SubRoom!.Room)
|
|
.Find(x => x.SubRoom.Id == subRoom.Id && x.InstanceType == Enums.RoomInstanceType.Private && x.EventId == -1).ToList();
|
|
|
|
return privateInstances.Count == 0
|
|
? CreateNewInstance(subRoom, Enums.RoomInstanceType.Private, true)
|
|
: privateInstances[0];
|
|
}
|
|
|
|
return joinMode switch
|
|
{
|
|
JoinType.PublicMatchmaking => GetOrCreatePublicInstance(subRoom),
|
|
JoinType.PublicNewInstance => CreateNewInstance(subRoom, Enums.RoomInstanceType.Public, false),
|
|
JoinType.PrivateNewInstance => CreateNewInstance(subRoom, Enums.RoomInstanceType.Private, true),
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private RoomInstance GetOrCreatePublicInstance(SubRoom subRoom)
|
|
{
|
|
var roomInstances = db.RoomInstances.Include(x => x.SubRoom).Include(x => x.SubRoom!.Room)
|
|
.Find(x => x.SubRoom.Id == subRoom.Id && x.InstanceType == Enums.RoomInstanceType.Public && x.EventId == -1).ToList();
|
|
|
|
return roomInstances.Count == 0
|
|
? CreateNewInstance(subRoom, Enums.RoomInstanceType.Public, false)
|
|
: roomInstances[Random.Shared.Next(roomInstances.Count)];
|
|
}
|
|
|
|
private async Task<IActionResult> ProcessPresenceTransitionAsync(AccountPresence presence, RoomInstance targetInstance, Account account, Room room, string appVersion)
|
|
{
|
|
if (presence.Instance?.Id == targetInstance.Id)
|
|
{
|
|
return Ok(new { errorCode = PLBMBHKLCHD.AlreadyInTargetInstance });
|
|
}
|
|
|
|
UpdateRoomStats(account, room);
|
|
|
|
presence.Instance = targetInstance;
|
|
presence.AppVersion = appVersion;
|
|
await SaveAndNotifyPresenceAsync(presence);
|
|
|
|
return Ok(new
|
|
{
|
|
errorCode = PLBMBHKLCHD.Success,
|
|
roomInstance = targetInstance.ToDictionary()
|
|
});
|
|
}
|
|
|
|
private static Room InitializeNewDormRoom(Account account, Room baseDorm)
|
|
{
|
|
return new Room
|
|
{
|
|
Name = Guid.NewGuid().ToString(),
|
|
IsDorm = true,
|
|
SupportedPlayerTypes = baseDorm.SupportedPlayerTypes,
|
|
Accessibility = RoomAccessibility.Private,
|
|
ImageName = baseDorm.ImageName,
|
|
Description = baseDorm.Description,
|
|
Creator = account,
|
|
CustomWarning = baseDorm.CustomWarning,
|
|
WarningMask = baseDorm.WarningMask,
|
|
DataBlob = baseDorm.DataBlob,
|
|
DisableMicAutoMute = baseDorm.DisableMicAutoMute,
|
|
DisableRoomComments = baseDorm.DisableRoomComments,
|
|
EncryptVoiceChat = baseDorm.EncryptVoiceChat,
|
|
MinLevel = baseDorm.MinLevel,
|
|
PersistenceVersion = baseDorm.PersistenceVersion
|
|
};
|
|
}
|
|
|
|
private void CloneSubRooms(Room targetRoom, Room sourceRoom, Account account, LoginWithInfoResult login)
|
|
{
|
|
var sourceSubRooms = db.SubRooms.Include(x => x.Room).Include(x => x.CurrentSave).Find(x => x.Room.Id == sourceRoom.Id);
|
|
|
|
foreach (var subRoom in sourceSubRooms)
|
|
{
|
|
var newSubRoom = new SubRoom
|
|
{
|
|
Room = targetRoom,
|
|
LocationId = subRoom.LocationId,
|
|
Name = subRoom.Name,
|
|
IsSandbox = subRoom.IsSandbox,
|
|
MaxPlayers = subRoom.MaxPlayers,
|
|
CanMatchmakeInto = subRoom.CanMatchmakeInto,
|
|
SupportsJoinInProgress = subRoom.SupportsJoinInProgress,
|
|
UseLevelBasedMatchmaking = subRoom.UseLevelBasedMatchmaking,
|
|
UseAgeBasedMatchmaking = subRoom.UseAgeBasedMatchmaking,
|
|
UseRecRoyaleMatchmaking = subRoom.UseRecRoyaleMatchmaking
|
|
};
|
|
db.SubRooms.Insert(newSubRoom);
|
|
|
|
if (subRoom.CurrentSave != null)
|
|
{
|
|
var newSave = new SubRoomSave
|
|
{
|
|
SubRoomId = newSubRoom.Id,
|
|
DataBlob = subRoom.CurrentSave.DataBlob,
|
|
SavedByAccountId = account.Id,
|
|
SavedOnPlatform = login.Platform,
|
|
SavedOnDeviceClass = login.DeviceClass,
|
|
Description = $"Cloned From ^{targetRoom.Name}",
|
|
UnityAssetId = subRoom.CurrentSave.UnityAssetId,
|
|
PersistenceVersion = subRoom.CurrentSave.PersistenceVersion
|
|
};
|
|
db.SubRoomSave.Insert(newSave);
|
|
|
|
newSubRoom.CurrentSave = newSave;
|
|
db.SubRooms.Update(newSubRoom);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateRoomStats(Account account, Room room)
|
|
{
|
|
lock (_statsLock)
|
|
{
|
|
if (!room.Stats.VisitorIds.Contains(account.Id))
|
|
{
|
|
room.Stats.VisitorIds.Add(account.Id);
|
|
}
|
|
room.Stats.VisitCount += 1;
|
|
db.Rooms.Update(room);
|
|
|
|
account.VisitedRooms[room.Id] = DateTime.UtcNow;
|
|
db.Accounts.Update(account);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |