public async virtual Task <PlayerGameItem> GetCurrentPlayerInstance()
{
PlayerGameItem player = new PlayerGameItem();
player.Id = GameManager.Instance.UserId;
return(player);
}
public async Task AddChild(string parentId, PlayerGameItem child)
{
//TODO: call the service to persistent child and update the parent-child relationship
child = await CreatePlayerGameItem(child);
await pgiRepository.UpdateParentChildRelation(parentId, child.Id, true);
}
public async Task <PlayerGameItem> CreatePlayerGameItem(PlayerGameItem item)
{
var playerString = JsonUtility.ToJson(item);
PlayerPrefs.SetString(PREFS_GAMEITEM_KEY + item.Id, playerString);
return(JsonUtility.FromJson <PlayerGameItem>(playerString));
}
/// <summary>
/// Bind a Character PlayerGameItem to this component, the prefab of of the Character will be displayed,
/// and the equipment will be equipped
/// </summary>
/// <param name="gameItem"></param>
/// <param name="localisablePrefabType"></param>
public virtual async Task BindCharacterPGI(PlayerGameItem gameItem, LocalisablePrefabType localisablePrefabType = LocalisablePrefabType.InGame)
{
if (gameItem == null || gameItem.GiType != typeof(Character).Name)
{
Debug.LogError("Only Character PlayerGameItem is allowed!");
return;
}
PlayerGameItem = gameItem;
await AttachCharacterPrefabById(gameItem.GiId, localisablePrefabType);
var equipments = gameItem.Equipments;//new List<CharacterEquipment>(GameManager.Instance.Players.Selected.PlayerDto.CharacterEquipments[gameItem.Id]);
if (equipments != null)
{
PopulateCharacterEquipments(equipments);
Updated = false;
if (!Updated)
{
//If the equipment is already displayed, we need to manually trigger the equipment process
//Otherwise it will be called automatically in RunMethod
await EquipAssets();
}
}
}
public async Task <List <PlayerGameItem> > GetEquipments(string itemId)
{
var Equipments = new List <PlayerGameItem>();
if (hasEquipment)
{
PlayerGameItem equipment = new PlayerGameItem();
equipment.GiType = "AddressableGameItem";
equipment.GiId = "AGI_Stick1";
equipment.Id = "4";
equipment.PrefabType = LocalisablePrefabType.InGame;
equipment.IsActive = true;
equipment.SetAttr(PlayerGameItem.ATTRS_SLOTTED, Enum.GetName(typeof(Slot), Slot.RHand));
Equipments.Add(equipment);
//Skin
PlayerGameItem skin = new PlayerGameItem();
skin.GiType = "AddressableGameItem";
skin.GiId = "AGI_BallFishSkin1";
skin.Id = "5";
skin.PrefabType = LocalisablePrefabType.InGame;
skin.IsActive = true;
skin.SetAttr(PlayerGameItem.ATTRS_SLOTTED, Enum.GetName(typeof(Slot), Slot.Body));
Equipments.Add(skin);
}
hasEquipment = !hasEquipment;
return(Equipments);
}
protected void DisplayPlayGameItems(Transform parent, PlayerGameItem item)
{
if (item != null)
{
//Get the position and rotation info for the GameItem
var position = item.GetVector3Attr(PlayerGameItem.ATTRS_POSITION, Vector3.zero);
var rotationVariable = item.GetVector3Attr(PlayerGameItem.ATTRS_ROTATION, Vector3.zero);
Quaternion rotation = Quaternion.Euler(rotationVariable);
GameObject gameObject = null;
if (item.GiType == typeof(Level).Name)
{
//Level
gameObject = Instantiate(LevelHolder,
position, rotation, parent);
}
else if (item.GiType == typeof(Character).Name)
{
//Create the character holder
gameObject = Instantiate(CharacterHolder,
position, rotation, parent);
//Config the prefab
var holderComponent = gameObject.GetComponent <CharacterHolder>();
holderComponent.BindCharacterPGI(item, item.PrefabType);
if (item.IsPlayerCharacter())
{
//Link to the player's character holder
PlayerCharacterHolder = gameObject;
}
}
else if (item.GiType == typeof(AddressableGameItem).Name)
{
AddressableGameItem gameItem = GameManager.Instance.AddressableGameItems.GetItem(item.GiId);
//Won't create GameObject for Skin (Texture).
if (gameItem.ContentType != Model.AddressableGameItemMeta.ContentType.Skin)
{
//AddressableGameItem
gameObject = Instantiate(AgiHolder,
position, rotation, parent);
//Config the prefab
var holderComponent = gameObject.GetComponent <AddressableGameItemHolder>();
holderComponent.Context.ContextMode = GameItems.ObjectModel.GameItemContext.ContextModeType.ByNumber;
holderComponent.Context.Number = item.GiId;
holderComponent.PrefabType = item.PrefabType;
holderComponent.PlayerGameItem = item;
}
}
if (item.Children != null && gameObject != null)
{
//Handle the children's display
foreach (var child in item.Children)
{
DisplayPlayGameItems(gameObject.transform, child);
}
}
}
}
/// <summary>
/// Populate the assets of the GameItems
/// </summary>
/// <param name="pgi"></param>
/// <returns></returns>
public async Task PopulateGameItem(PlayerGameItem pgi)
{
Dictionary <string, List <string> > gameItems = new Dictionary <string, List <string> >();
FetchGameItems(pgi, gameItems);
//Load the GameItem assets.
var resources = gameItems.Select(pair => GameManager.Instance.GetIBaseGameItemManager(pair.Key).LoadAddressableResources(pair.Value));
await Task.WhenAll(resources);
}
public async Task <PlayerGameItem> GetPlayerInstance()
{
//TODO:Get player profile by token
string token = await LoadToken();
string playerId = GameManager.Instance.UserId;
PlayerGameItem player = await GetPlayerGameItem(playerId);
return(player);
}
public async virtual Task <PlayerGameItem> GetPlayerGameItem(string itemId)
{
PlayerGameItem character = new PlayerGameItem();
character.GiType = "Character";
character.GiId = "Character_BallFish";
character.Id = itemId;
character.PrefabType = LocalisablePrefabType.Type1;
character.IsActive = true;
character.SetFloatAttr(PlayerGameItem.ATTRS_HEALTH, UnityEngine.Random.Range(0, 100));
return(character);
}
/// <summary>
/// Get the GameItems from the PlayerGameItem and its children, then we can preload the resources in GameItems
/// </summary>
/// <param name="pgi"></param>
/// <param name="gameItems"></param>
private void FetchGameItems(PlayerGameItem pgi, Dictionary <string, List <string> > gameItems)
{
List <string> items;
if (pgi.GiType == typeof(Character).Name && pgi.GetBoolAttr(PlayerGameItem.ATTRS_IS_PLAYER))
{
SelectedCharacter = pgi;
}
gameItems.TryGetValue(pgi.GiType, out items);
if (items == null)
{
items = new List <string>();
items.Add(pgi.GiId);
gameItems[pgi.GiType] = items;
}
else if (!items.Contains(pgi.GiId))
{
items.Add(pgi.GiId);
}
if (pgi.Children != null)
{
foreach (var child in pgi.Children)
{
FetchGameItems(child, gameItems);
}
}
if (pgi.Equipments != null)
{
//Load equipments
foreach (var equipment in pgi.Equipments)
{
FetchGameItems(equipment, gameItems);
}
}
//if (pgi.CharacterEquipments != null)
//{
// //Load equipments
// foreach (var equipment in pgi.CharacterEquipments)
// {
// var equipItem = GameManager.Instance.PlayerGameItems.GetPlayerGameItemById(equipment.GameItemId);
// if (equipItem != null)
// {
// FetchGameItems(equipItem, gameItems);
// }
// }
//}
}
public override bool RunMethod(EquipmentUpdatedMessage message)
{
if (itemHolder != null && message.CharacterId == itemHolder.PlayerGameItem.Id)
{
//It's me to update the equipment
PlayerGameItem character = GameManager.Instance.PlayerGameItems.GetPlayerGameItemById(message.CharacterId);
//Update the equipment list
character.Equipments = message.NewEquipments;
//Rebind
((CharacterHolder)this.itemHolder).BindCharacterPGI(character, character.PrefabType);
}
return(true);
}
public async Task <PlayerGameItem> GetCurrentPlayerInstance()
{
Channel channel = ChannelFactory.GetChannel();
var client = new UserInfo.UserInfoClient(channel);
var reply = await client.GetUserInfoAsync(new Google.Protobuf.WellKnownTypes.Empty());
channel.ShutdownAsync().Wait();
PlayerGameItem player = new PlayerGameItem();
player.Id = reply.Uid;
player.CustomName = reply.Nickname;
return(player);
}
public async Task <PlayerGameItem> GetPlayerGameItem(string itemId)
{
PlayerGameItem player = await HttpUtil.GetDummyAsync <PlayerGameItem>(GlobalConstants.SERVER_TISVC_PREFIX + "/Player");
string playerString = PlayerPrefs.GetString(PREFS_GAMEITEM_KEY + itemId);
if (string.IsNullOrEmpty(playerString))
//if (true)
{
player = null;
//Commented as we want to trigger the new account creation in client
//Create the default one
//playerString = JsonUtility.ToJson(MockPlayerInstance());
//PlayerPrefs.SetString(DUMMY_PREFS_KEY + playerId, playerString);
}
player = JsonUtility.FromJson <PlayerGameItem>(playerString);
return(player);
}
protected List <PlayerGameItem> GenerateSeaweeds()
{
List <PlayerGameItem> seaweeds = new List <PlayerGameItem>();
for (int i = 0; i < 20; i++)
{
PlayerGameItem seaweed = new PlayerGameItem();
seaweed.GiType = "AddressableGameItem";
seaweed.GiId = "AGI_Seaweeds";
seaweed.Id = seaweed.GiId + i;
seaweed.PrefabType = (i % (LocalisablePrefabType.Type7 - LocalisablePrefabType.Type1 + 1) + LocalisablePrefabType.Type1);
seaweed.SetVector3Attr(PlayerGameItem.ATTRS_POSITION, new Vector3(UnityEngine.Random.Range(-80, 80) / 10.0f,
0, UnityEngine.Random.Range(-70, 120) / 10.0f));
seaweed.SetVector3Attr(PlayerGameItem.ATTRS_ROTATION, Quaternion.identity.eulerAngles);
seaweeds.Add(seaweed);
//seaweed.Props = Variables.FromJsonMapString(seaweed.Props.ToJsonMapString());
//Debug.Log(seaweed.Props.ToJsonMapString());
}
return(seaweeds);
}
private PlayerGameItem SearchPlayerGameItem(string id, PlayerGameItem root)
{
if (root.Id == id)
{
return(root);
}
else
{
if (root.Children != null)
{
//Search in children
foreach (var child in root.Children)
{
var item = SearchPlayerGameItem(id, child);
if (item != null)
{
return(item);
}
}
}
}
return(null);
}
private async Task HandlePlatformMessage(PlatformMessage message)
{
//Convert the PlatformMessage to specific message or handle it directly
if (message.Content.ContainsKey(PlatformMessage.TYPE))
{
string type = message.Content[PlatformMessage.TYPE] as string;
if (type == PlatformMessage.TYPE_CREATION_UPDATED)
{
//Creation properties updated
string itemId = (string)message.Content[PlatformMessage.CONTENT_PGI_ID];
PlayerGameItem newItem = await PlayerGameItemService.Instance.GetPlayerGameItem(itemId);
//Clone the oldItem to avoid some message receiver may change the origin item
PlayerGameItem oldItem = JsonUtility.FromJson <PlayerGameItem>(JsonUtility.ToJson(GameManager.Instance.PlayerGameItems.GetPlayerGameItemById(newItem.Id)));
PlayerGameItemUpdatedMessage pgiMessage = new PlayerGameItemUpdatedMessage(oldItem, newItem);
GameManager.SafeQueueMessage(pgiMessage);
return;
}
else if (type == PlatformMessage.TYPE_EQUIPMENT_UPDATED)
{
//Equipment updated
string itemId = (string)message.Content[PlatformMessage.CONTENT_PGI_ID];
List <PlayerGameItem> newEquipments = await PlayerGameItemService.Instance.GetEquipments(itemId);
//Copy the item to avoid some message receiver may change the origin item
List <PlayerGameItem> oldEquipments = JsonUtil.ListFromJson <PlayerGameItem>(JsonUtil.ListToJson <PlayerGameItem>(GameManager.Instance.PlayerGameItems.SelectedCharacter.Equipments));
EquipmentUpdatedMessage eqMessage = new EquipmentUpdatedMessage(itemId, oldEquipments, newEquipments);
GameManager.SafeQueueMessage(eqMessage);
return;
}
}
}
public virtual Task <PlayerGameItem> CreatePlayerGameItem(PlayerGameItem item)
{
throw new NotImplementedException();
}
private PlayerGameItem PopulatePlayerGameItem(Creation.Creation creation)
{
PlayerGameItem item = null;
if (creation != null)
{
//Copy the fields
item = new PlayerGameItem();
item.GiType = creation.CreationType;
item.GiId = creation.Template;
item.Id = creation.Id;
Enum.TryParse(creation.PrefabType, out item.PrefabType);
item.CustomName = creation.Name;
item.ModelVersion = creation.SchemaVersion;
item.IsActive = "active" == creation.Status;
item.Category = creation.Category;
//The props the logic cares
if (creation.Attrs != null)
{
foreach (var pair in creation.Attrs)
{
item.Attrs.Add(pair.Key, pair.Value);
}
}
//The extra props
if (creation.ExtraProps != null)
{
item.ExtraProps = Variables.FromDict(creation.ExtraProps);
}
//The children
if (creation.Children != null && creation.Children.Count > 0)
{
var children = new List <PlayerGameItem>();
var equipments = new List <PlayerGameItem>();
foreach (var child in creation.Children)
{
var subItem = PopulatePlayerGameItem(child);
if (subItem.Category == "uw:pet:equipment")
{
//Equipment
if (subItem.IsActive)
{
//Only equip the actived item
equipments.Add(subItem);
}
}
else
{
//Normal item
children.Add(PopulatePlayerGameItem(child));
}
}
if (children.Count > 0)
{
item.Children = children;
}
if (equipments.Count > 0)
{
item.Equipments = equipments;
}
}
}
return(item);
}
public async Task <PlayerGameItem> CreatePlayerGameItem(PlayerGameItem item)
{
return(await pgiRepository.CreatePlayerGameItem(item));
}
public virtual async Task BindItem(CharacterHolder holderComponent, PlayerGameItem item)
{
await holderComponent.BindCharacterPGI(item, item.PrefabType);
}
public PlayerGameItemUpdatedMessage(PlayerGameItem oldItem, PlayerGameItem newItem)
{
OldItem = oldItem;
NewItem = newItem;
}
public async virtual Task <PlayerGameItem> LoadCurrentScene(string theme)
{
PlayerGameItem scene = new PlayerGameItem();
scene.GiType = "Level";
scene.GiId = "Level_sea1";
scene.Id = "1";
scene.PrefabType = LocalisablePrefabType.InGame;
//Generate the seaweeds
scene.Children = GenerateSeaweeds();
//Generate character
PlayerGameItem character = new PlayerGameItem();
character.GiType = "Character";
character.GiId = "Character_Turtle";
character.Id = "2";
character.PrefabType = LocalisablePrefabType.Type1;
character.SetBoolAttr(PlayerGameItem.ATTRS_IS_PLAYER, true);
scene.Children.Add(character);
//Generate character
character = new PlayerGameItem();
character.GiType = "Character";
character.GiId = "Character_BallFish";
character.Id = "3";
character.PrefabType = LocalisablePrefabType.Type1;
character.IsActive = false;
scene.Children.Add(character);
//Equipment: stick
PlayerGameItem equipment = new PlayerGameItem();
equipment.GiType = "AddressableGameItem";
equipment.GiId = "AGI_Stick1";
equipment.Id = "4";
equipment.PrefabType = LocalisablePrefabType.InGame;
equipment.IsActive = true;
equipment.SetAttr(PlayerGameItem.ATTRS_SLOTTED, Enum.GetName(typeof(Slot), Slot.RHand));
character.Equipments = new List <PlayerGameItem>();
character.Equipments.Add(equipment);
//Skin
PlayerGameItem skin = new PlayerGameItem();
skin.GiType = "AddressableGameItem";
skin.GiId = "AGI_BallFishSkin1";
skin.Id = "5";
skin.PrefabType = LocalisablePrefabType.InGame;
skin.IsActive = true;
skin.SetAttr(PlayerGameItem.ATTRS_SLOTTED, Enum.GetName(typeof(Slot), Slot.Body));
character.Equipments.Add(skin);
//Debug.Log(JsonUtility.ToJson(scene));
//Debug.Log(JsonConvert.SerializeObject(scene));
return(scene);
}
