/// <inheritdoc />
public PreBurstSessionClaimOnClientConnectionEventListener(INetworkConnectionEstablishedEventSubscribable subscriptionService, [NotNull] IPeerPayloadSendService <GameClientPacketPayload> sendService, [NotNull] IReadonlyAuthTokenRepository authTokenRepository, [NotNull] ICharacterDataRepository characterDataRepository)
: base(subscriptionService)
{
SendService = sendService ?? throw new ArgumentNullException(nameof(sendService));
AuthTokenRepository = authTokenRepository ?? throw new ArgumentNullException(nameof(authTokenRepository));
CharacterDataRepository = characterDataRepository ?? throw new ArgumentNullException(nameof(characterDataRepository));
}
/// <inheritdoc />
public WorldDownloadingGameInitializable(ICharacterService characterService, ICharacterDataRepository localCharacterData, IReadonlyAuthTokenRepository authTokenRepo, IZoneServerService zoneDataService, IContentServerServiceClient contentService, ILog logger)
{
CharacterService = characterService;
LocalCharacterData = localCharacterData;
AuthTokenRepo = authTokenRepo;
ZoneDataService = zoneDataService;
ContentService = contentService;
Logger = logger;
}
//TODO: Secure this so only authenticated zoneservers who own a claimed session of for this character can update their data.
//[ProducesJson]
//[HttpPatch("{id}/UpdateData")]
//[NoResponseCache]
private async Task <IActionResult> UpdatePlayerData([FromRoute(Name = "id")] int characterId,
[FromBody][NotNull] CharacterDataInstance requestModel,
[FromServices][NotNull] ICharacterDataRepository characterDataRepository)
{
CharacterDataModel dataModel = await characterDataRepository.RetrieveAsync(characterId);
//TODO: Make this updatable
dataModel.ExperiencePoints = requestModel.Experience;
await characterDataRepository.UpdateAsync(characterId, dataModel);
return(Ok());
}
/// <inheritdoc />
public CharacterSelectionSelectCharacterImmediatelyOnButtonClickedEventListener(
[NotNull] ICharacterSelectionButtonClickedEventSubscribable subscriptionService,
[NotNull] ICharacterService characterService,
[NotNull] ICharacterDataRepository characterData,
[NotNull] IReadonlyAuthTokenRepository authTokenRepo,
[NotNull] ILog logger)
: base(subscriptionService)
{
CharacterService = characterService ?? throw new ArgumentNullException(nameof(characterService));
CharacterData = characterData ?? throw new ArgumentNullException(nameof(characterData));
AuthTokenRepo = authTokenRepo ?? throw new ArgumentNullException(nameof(authTokenRepo));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public CharacterCreationViewController(
ICharacterCreationView view,
ICharacterDataRepository characterDataRepository,
IBackgroundRepository backgroundRepository,
ICharacterRepository characterRepository,
CharacterMapper characterMapper,
CharacterManager characterManager) : base(view)
{
this.characterDataRepository = characterDataRepository;
this.backgroundRepository = backgroundRepository;
this.characterRepository = characterRepository;
this.characterMapper = characterMapper;
this.characterManager = characterManager;
}
public async Task <IActionResult> GetCharacterData([FromRoute(Name = "id")] int characterId,
[FromServices][NotNull] ICharacterDataRepository characterDataRepository)
{
//TODO: We should only let the user themselves get their own character's data OR zoneservers who have a claimed session.
ProjectVersionStage.AssertBeta();
if (!await characterDataRepository.ContainsAsync(characterId))
{
return(BuildFailedResponseModel(CharacterDataQueryReponseCode.CharacterNotFound));
}
CharacterDataModel characterData = await characterDataRepository.RetrieveAsync(characterId);
return(BuildSuccessfulResponseModel(new CharacterDataInstance(characterData.ExperiencePoints)));
}
public async Task <IActionResult> SaveFullCharacterDataAsync([FromRoute(Name = "id")] int characterId,
[FromBody][NotNull] FullCharacterDataSaveRequest request,
[NotNull][FromServices] ICharacterLocationRepository locationRepository,
[NotNull][FromServices] IZoneServerRepository zoneRepository,
[FromServices][NotNull] ICharacterDataRepository characterDataRepository)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (characterId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(characterId));
}
//TODO: Is it safe to not do this as a transaction??
//TODO: For HTTP callers we should maybe include better information. Though with message queue we can't respond.
if (!await CheckZoneAuthorizedToModifyCharacterData(characterId))
{
return(Forbid());
}
//Don't always want to save the position of the user.
if (request.isPositionSaved)
{
await UpdateCharacterLocation(characterId, request.CharacterLocationData, locationRepository, zoneRepository);
}
//TODO: Probably need to handle this abit better and more data than just experience.
//Entity data can now be saved.
await UpdatePlayerData(characterId, new CharacterDataInstance(request.PlayerDataSnapshot.GetFieldValue <int>(PlayerObjectField.PLAYER_TOTAL_EXPERIENCE)), characterDataRepository);
if (request.ShouldReleaseCharacterSession)
{
await CharacterSessionRepository.TryDeleteClaimedSession(characterId);
}
return(Ok());
}
public MainMenuViewController(IMainMenuView view, ICharacterDataRepository characterDataRepository) : base(view)
{
this.characterDataRepository = characterDataRepository;
}
/// <inheritdoc />
public PreBurstStartInstanceClientConnection([NotNull] IManagedNetworkClient <GameClientPacketPayload, GameServerPacketPayload> client, [NotNull] ICharacterService characterDataService, [NotNull] IReadonlyAuthTokenRepository authTokenRepo, [NotNull] ICharacterDataRepository characterDataRepo, [NotNull] IZoneServerService zoneService, [NotNull] ILog logger, [NotNull] INetworkClientManager networkClientManager)
{
Client = client ?? throw new ArgumentNullException(nameof(client));
CharacterDataService = characterDataService ?? throw new ArgumentNullException(nameof(characterDataService));
AuthTokenRepo = authTokenRepo ?? throw new ArgumentNullException(nameof(authTokenRepo));
CharacterDataRepo = characterDataRepo ?? throw new ArgumentNullException(nameof(characterDataRepo));
ZoneService = zoneService ?? throw new ArgumentNullException(nameof(zoneService));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
NetworkClientManager = networkClientManager ?? throw new ArgumentNullException(nameof(networkClientManager));
}
public async Task <IActionResult> CreateCharacter([FromRoute] string name,
[FromServices][NotNull] IPlayfabCharacterClient playfabCharacterClient,
[FromServices][NotNull] ICharacterAppearanceRepository characterAppearanceRepository,
[FromServices][NotNull] ICharacterDataRepository characterDataRepository)
{
if (playfabCharacterClient == null)
{
throw new ArgumentNullException(nameof(playfabCharacterClient));
}
if (characterAppearanceRepository == null)
{
throw new ArgumentNullException(nameof(characterAppearanceRepository));
}
if (characterDataRepository == null)
{
throw new ArgumentNullException(nameof(characterDataRepository));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(name));
}
int accountId = ClaimsReader.GetAccountIdInt(User);
bool nameIsAvailable = await ValidateNameAvailability(name);
if (!nameIsAvailable)
{
return(BadRequest(new CharacterCreationResponse(CharacterCreationResponseCode.NameUnavailableError)));
}
string playfabId = ClaimsReader.GetPlayfabId(User);
//Now, we actually need to create the character on PlayFab first. It's better to have an orphaned character on PlayFab
//than to have a character without a PlayFab equivalent.
PlayFabResultModel <GladMMOPlayFabGrantCharacterToUserResult> playFabResultModel = await playfabCharacterClient.GrantCharacterToUser(new GladMMOPlayFabGrantCharacterToUserRequest(name, "test", playfabId));
//TODO: Better error handling
if (playFabResultModel.ResultCode != HttpStatusCode.OK)
{
if (Logger.IsEnabled(LogLevel.Error))
{
Logger.LogError($"PlayFab CharacterCreation Erorr: {playFabResultModel.ResultCode}:{playFabResultModel.ResultStatus}");
}
return(BadRequest(new CharacterCreationResponse(CharacterCreationResponseCode.GeneralServerError)));
}
CharacterEntryModel characterEntryModel = new CharacterEntryModel(accountId, name, playfabId, playFabResultModel.Data.CharacterId);
//TODO: We need a transition around the creation of the below entries.
ProjectVersionStage.AssertBeta();
//TODO: Don't expose the database table model
//Otherwise we should try to create. There is a race condition here that can cause it to still fail
//since others could create a character with this name before we finish after checking
bool result = await CharacterRepository.TryCreateAsync(characterEntryModel);
//TODO: Also needs to be apart of the transaction
if (result)
{
await characterDataRepository.TryCreateAsync(new CharacterDataModel(characterEntryModel.CharacterId, 0));
await characterAppearanceRepository.TryCreateAsync(new CharacterAppearanceModel(characterEntryModel.CharacterId, 9)); //Default is 9 right now.
}
return(Json(new CharacterCreationResponse(CharacterCreationResponseCode.Success)));
}
/// <inheritdoc />
public ZoneClientCharacterSessionInitializable(IPeerPayloadSendService <GameClientPacketPayload> payloadSender, ICharacterDataRepository characterRepository)
{
PayloadSender = payloadSender;
CharacterRepository = characterRepository;
}
