/// <summary>
/// Loads the reward on model.
/// </summary>
/// <param name="rewardPackUnlockData">The identifier.</param>
/// <returns></returns>
private GameObject LoadRewardPropOnAntura(RewardPack rewardPack)
{
RewardProp prop = rewardPack.RewardBase as RewardProp;
if (prop == null)
{
Debug.LogFormat("Prop {0} not found!", rewardPack.BaseId);
return(null);
}
// Check if we already loaded a reward of this category
LoadedModel loadedModel = LoadedModels.Find(lm => lm.RewardPack.Category == prop.Category);
if (loadedModel != null)
{
Destroy(loadedModel.GO);
LoadedModels.Remove(loadedModel);
}
// Load Model
string boneParent = prop.BoneAttach;
GameObject rewardModel = null;
switch (boneParent)
{
case "dog_head":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_head);
break;
case "dog_spine01":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_spine01);
break;
case "dog_jaw":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_jaw);
break;
case "dog_Tail4":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_Tail3);
break;
case "dog_R_ear04":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_R_ear04);
break;
case "dog_L_ear04":
rewardModel = ModelsManager.MountModel(prop.ID, Dog_L_ear04);
break;
}
// Set materials
ModelsManager.SwitchMaterial(rewardModel, rewardPack.GetMaterialPair());
// Save on LoadedModel List
LoadedModels.Add(new LoadedModel()
{
RewardPack = rewardPack, GO = rewardModel
});
return(rewardModel);
}
public void OpenWindow(NestedWeightedRewardPack nestedRewardPack)
{
currentRewardPack = nestedRewardPack.GetPackByWeight(out packIndex);
currentRewardPack.Use();
if (nestedRewardPack.Packs.Count != count)
{
return;
}
spinButton.gameObject.SetActive(true);
var t = startOffsetDeg * Mathf.Deg2Rad;
for (int i = 0; i < count; i++)
{
var pack = nestedRewardPack.Packs[i];
for (int j = 0; j < pack.Rewards.Count; j++)
{
var rewardSource = pack.Rewards[j];
var cloned = pool.GetOrInstantiate(rewardSource.Source.TypeId);
cloned.Source = rewardSource;
cloned.Init();
cloned.transform.localPosition = new Vector3(radius * Mathf.Cos(t), radius * Mathf.Sin(t));
cloned.transform.localEulerAngles = new Vector3(0, 0, t * Mathf.Rad2Deg + rotateElementOffsetDeg);
}
t += delta;
}
OpenWindow();
}
private void RewardSystemManager_OnRewardItemChanged(RewardPack rewardPack)
{
LoadRewardPackOnAntura(rewardPack);
//rewardPack.SetNew(false);
AppManager.I.RewardSystemManager.SaveRewardsUnlockDataChanges();
SaveAnturaCustomization();
}
public GameObject LoadRewardPackOnAntura(RewardPack rewardPack)
{
if (rewardPack == null)
{
return(null);
}
switch (rewardPack.BaseType)
{
case RewardBaseType.Prop:
return(LoadRewardPropOnAntura(rewardPack));
case RewardBaseType.Texture:
var newMaterial = MaterialManager.LoadTextureMaterial(rewardPack.BaseId, rewardPack.ColorId);
// Main mesh
var mats = SkinnedMesh.sharedMaterials;
mats[0] = newMaterial;
SkinnedMesh.sharedMaterials = mats;
LoadedTexturePack = rewardPack;
// Sup mesh for texture
foreach (var _renderer in SkinnedMeshsTextureOnly)
{
var materials = _renderer.sharedMaterials;
materials[0] = newMaterial;
_renderer.sharedMaterials = materials;
}
break;
case RewardBaseType.Decal:
Material newDecalMaterial = MaterialManager.LoadTextureMaterial(rewardPack.BaseId, rewardPack.ColorId);
// Main mesh
Material[] decalMats = SkinnedMesh.sharedMaterials;
decalMats[1] = newDecalMaterial;
SkinnedMesh.sharedMaterials = decalMats;
// Sup mesh for texture
foreach (SkinnedMeshRenderer _renderer in SkinnedMeshsTextureOnly)
{
Material[] materials = _renderer.sharedMaterials;
materials[1] = newDecalMaterial;
_renderer.sharedMaterials = materials;
}
LoadedDecalPack = rewardPack;
break;
default:
Debug.LogWarningFormat("Reward Type {0} not found!", rewardPack.BaseType);
break;
}
return(null);
}
/// <summary>
/// Loads all rewards in "this" object instance from list of reward ids.
/// </summary>
/// <param name="_listOfIdsAsJsonString">The list of ids as json string.</param>
public void LoadFromListOfIds(string _listOfIdsAsJsonString)
{
if (AppManager.I.Player == null)
{
Debug.Log("No default reward already created. Unable to load customization now");
return;
}
AnturaCustomization tmp = JsonUtility.FromJson <AnturaCustomization>(_listOfIdsAsJsonString);
if (tmp != null)
{
PropPacksIds = tmp.PropPacksIds;
TexturePackId = tmp.TexturePackId;
DecalPackId = tmp.DecalPackId;
}
var rewardSystem = AppManager.I.RewardSystemManager;
if (string.IsNullOrEmpty(TexturePackId))
{
RewardPack defaultTileTexturePack = rewardSystem.GetAllRewardPacksOfBaseType(RewardBaseType.Texture)[0];
Debug.LogWarning("AnturaCustomization: Using default texture: " + defaultTileTexturePack);
TexturePackId = defaultTileTexturePack.UniqueId;
}
if (string.IsNullOrEmpty(DecalPackId))
{
RewardPack defaultDecalTexturePack = rewardSystem.GetAllRewardPacksOfBaseType(RewardBaseType.Decal)[0];
Debug.LogWarning("AnturaCustomization: Using default decal: " + defaultDecalTexturePack);
DecalPackId = defaultDecalTexturePack.UniqueId;
}
// Load correct packs from IDs
PropPacks = new List <RewardPack>();
foreach (string propPackId in PropPacksIds)
{
var pack = rewardSystem.GetRewardPackByUniqueId(propPackId);
if (pack != null)
{
PropPacks.Add(pack);
}
}
TexturePack = rewardSystem.GetRewardPackByUniqueId(TexturePackId);
DecalPack = rewardSystem.GetRewardPackByUniqueId(DecalPackId);
}
/// <summary>
/// Sets the reward material colors.
/// </summary>
/// <param name="_gameObject">The game object.</param>
/// <param name="rewardPackUnlockData">The reward pack.</param>
/// <returns></returns>
public GameObject SetRewardMaterialColors(GameObject _gameObject, RewardPack rewardPack)
{
ModelsManager.SwitchMaterial(_gameObject, rewardPack.GetMaterialPair());
//actualRewardsForCategoryColor.Add()
return(_gameObject);
}
public void OpenWindow(RewardPack pack)
{
this.pack = pack;
OpenWindow();
}
