public async UniTaskVoid OpenStorage(long connectionId, IPlayerCharacterData playerCharacter, StorageId storageId)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (!CanAccessStorage(playerCharacter, storageId))
{
GameInstance.ServerGameMessageHandlers.SendGameMessage(connectionId, UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE);
return;
}
// Store storage usage states
if (!usingStorageClients.ContainsKey(storageId))
{
usingStorageClients.TryAdd(storageId, new HashSet <long>());
}
usingStorageClients[storageId].Add(connectionId);
usingStorageIds.TryRemove(connectionId, out _);
usingStorageIds.TryAdd(connectionId, storageId);
// Load storage items from database
ReadStorageItemsReq req = new ReadStorageItemsReq();
req.StorageType = (EStorageType)storageId.storageType;
req.StorageOwnerId = storageId.storageOwnerId;
ReadStorageItemsResp resp = await DbServiceClient.ReadStorageItemsAsync(req);
List <CharacterItem> storageItems = DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems);
SetStorageItems(storageId, storageItems);
// Notify storage items to client
uint storageObjectId;
Storage storage = GetStorage(storageId, out storageObjectId);
GameInstance.ServerGameMessageHandlers.NotifyStorageOpened(connectionId, storageId.storageType, storageId.storageOwnerId, storageObjectId, storage.weightLimit, storage.slotLimit);
storageItems.FillEmptySlots(storage.slotLimit > 0, storage.slotLimit);
GameInstance.ServerGameMessageHandlers.NotifyStorageItems(connectionId, storageItems);
#endif
}
public async UniTask <DecreaseStorageItemsResult> DecreaseStorageItems(StorageId storageId, int dataId, short amount)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
Storage storge = GetStorage(storageId, out _);
DecreaseStorageItemsReq req = new DecreaseStorageItemsReq();
req.StorageType = (EStorageType)storageId.storageType;
req.StorageOwnerId = storageId.storageOwnerId;
req.WeightLimit = storge.weightLimit;
req.SlotLimit = storge.slotLimit;
req.DataId = dataId;
req.Amount = amount;
DecreaseStorageItemsResp resp = await DbServiceClient.DecreaseStorageItemsAsync(req);
if (UITextKeys.NONE != (UITextKeys)resp.Error)
{
// Error ocurring, storage may overwhelming let's it drop items to ground
return(new DecreaseStorageItemsResult());
}
SetStorageItems(storageId, DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems));
NotifyStorageItemsUpdated(storageId.storageType, storageId.storageOwnerId);
Dictionary <int, short> decreasedItems = new Dictionary <int, short>();
foreach (ItemIndexAmountMap entry in resp.DecreasedItems)
{
decreasedItems.Add(entry.Index, (short)entry.Amount);
}
return(new DecreaseStorageItemsResult()
{
IsSuccess = true,
DecreasedItems = decreasedItems,
});
#else
return(new DecreaseStorageItemsResult());
#endif
}
private async UniTaskVoid HandleRequestCharactersRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCharactersMessage message = messageHandler.ReadMessage <RequestCharactersMessage>();
ResponseCharactersMessage.Error error = ResponseCharactersMessage.Error.None;
List <PlayerCharacterData> characters = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseCharactersMessage.Error.NotLoggedin;
}
else
{
CharactersResp charactersResp = await DbServiceClient.ReadCharactersAsync(new ReadCharactersReq()
{
UserId = userPeerInfo.userId
});
characters = DatabaseServiceUtils.MakeListFromRepeatedByteString <PlayerCharacterData>(charactersResp.List);
}
ResponseCharactersMessage responseMessage = new ResponseCharactersMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCharactersMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.characters = characters;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseCharacters, responseMessage);
}
protected async UniTaskVoid HandleRequestCharacters(
RequestHandlerData requestHandler,
EmptyMessage request,
RequestProceedResultDelegate <ResponseCharactersMessage> result)
{
long connectionId = requestHandler.ConnectionId;
ResponseCharactersMessage.Error error = ResponseCharactersMessage.Error.None;
List <PlayerCharacterData> characters = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseCharactersMessage.Error.NotLoggedin;
}
else
{
CharactersResp charactersResp = await DbServiceClient.ReadCharactersAsync(new ReadCharactersReq()
{
UserId = userPeerInfo.userId
});
characters = DatabaseServiceUtils.MakeListFromRepeatedByteString <PlayerCharacterData>(charactersResp.List);
}
// Response
result.Invoke(
error == ResponseCharactersMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
error = error,
characters = characters,
});
}
protected async UniTaskVoid HandleRequestCharacters(
RequestHandlerData requestHandler,
EmptyMessage request,
RequestProceedResultDelegate <ResponseCharactersMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
List <PlayerCharacterData> characters = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
CharactersResp charactersResp = await DbServiceClient.ReadCharactersAsync(new ReadCharactersReq()
{
UserId = userPeerInfo.userId
});
characters = DatabaseServiceUtils.MakeListFromRepeatedByteString <PlayerCharacterData>(charactersResp.List);
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
message = message,
characters = characters,
});
#endif
}
public async UniTaskVoid HandleRequestMoveItemFromStorage(RequestHandlerData requestHandler, RequestMoveItemFromStorageMessage request, RequestProceedResultDelegate <ResponseMoveItemFromStorageMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
StorageId storageId = new StorageId(request.storageType, request.storageOwnerId);
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (!GameInstance.ServerStorageHandlers.CanAccessStorage(playerCharacter, storageId))
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
Storage storage = GameInstance.ServerStorageHandlers.GetStorage(storageId, out _);
MoveItemFromStorageReq req = new MoveItemFromStorageReq();
req.StorageType = (EStorageType)request.storageType;
req.StorageOwnerId = request.storageOwnerId;
req.CharacterId = playerCharacter.Id;
req.WeightLimit = storage.weightLimit;
req.SlotLimit = storage.slotLimit;
req.StorageItemIndex = request.storageItemIndex;
req.StorageItemAmount = request.storageItemAmount;
req.InventoryItemIndex = request.inventoryItemIndex;
MoveItemFromStorageResp resp = await DbServiceClient.MoveItemFromStorageAsync(req);
UITextKeys message = (UITextKeys)resp.Error;
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = message,
});
return;
}
playerCharacter.NonEquipItems = DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.InventoryItemItems);
GameInstance.ServerStorageHandlers.SetStorageItems(storageId, DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems));
GameInstance.ServerStorageHandlers.NotifyStorageItemsUpdated(request.storageType, request.storageOwnerId);
// Success
result.Invoke(AckResponseCode.Success, new ResponseMoveItemFromStorageMessage());
#endif
}
public async UniTask <bool> IncreaseStorageItems(StorageId storageId, CharacterItem addingItem)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
Storage storge = GetStorage(storageId, out _);
IncreaseStorageItemsReq req = new IncreaseStorageItemsReq();
req.StorageType = (EStorageType)storageId.storageType;
req.StorageOwnerId = storageId.storageOwnerId;
req.WeightLimit = storge.weightLimit;
req.SlotLimit = storge.slotLimit;
req.Item = DatabaseServiceUtils.ToByteString(addingItem);
IncreaseStorageItemsResp resp = await DbServiceClient.IncreaseStorageItemsAsync(req);
if (UITextKeys.NONE != (UITextKeys)resp.Error)
{
// Error ocurring, storage may overwhelming let's it drop items to ground
return(false);
}
SetStorageItems(storageId, DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems));
NotifyStorageItemsUpdated(storageId.storageType, storageId.storageOwnerId);
return(true);
#else
return(false);
#endif
}
