using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
namespace Snxxz.UI
|
{
|
public class AlchemyModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
Dictionary<int, uint> m_AlchemyTimes = new Dictionary<int, uint>();
|
Dictionary<int, AlchemyCount> m_AlchemyCounts = new Dictionary<int, AlchemyCount>();
|
Dictionary<int, int> m_AlchemyQualityLucks = new Dictionary<int, int>();
|
Dictionary<int, List<Item>> m_AlchemyMaterials = new Dictionary<int, List<Item>>();
|
|
int m_SelectQuality = 0;
|
public int selectQuality
|
{
|
get { return m_SelectQuality; }
|
set
|
{
|
if (m_SelectQuality != value)
|
{
|
m_SelectQuality = value;
|
if (selectQualityRefresh != null)
|
{
|
selectQualityRefresh();
|
}
|
}
|
}
|
}
|
|
int m_SelectAlchemy = 0;
|
public int selectAlchemy
|
{
|
get { return m_SelectAlchemy; }
|
set
|
{
|
if (m_SelectAlchemy != value)
|
{
|
m_SelectAlchemy = value;
|
if (selectAlchemyRefresh != null)
|
{
|
selectAlchemyRefresh();
|
}
|
}
|
}
|
}
|
|
public int stoveLevel { get; private set; }
|
public int stoveExp { get; private set; }
|
public string alchemySuccRate { get; private set; }
|
|
public event Action selectQualityRefresh;
|
public event Action selectAlchemyRefresh;
|
public event Action alchemyStateRefresh;
|
|
public override void Init()
|
{
|
ParseConfig();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
m_AlchemyTimes.Clear();
|
stoveLevel = 0;
|
stoveExp = 0;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
}
|
|
void ParseConfig()
|
{
|
{
|
var configs = AlchemyCountConfig.GetValues();
|
foreach (var config in configs)
|
{
|
var intArray = LitJson.JsonMapper.ToObject<int[][]>(config.CntRateList);
|
var min = intArray[0][1];
|
var max = intArray[intArray.Length - 1][1];
|
if (m_AlchemyCounts.ContainsKey(config.AlchemyQuality))
|
{
|
var alchemyCount = m_AlchemyCounts[config.AlchemyQuality];
|
if (min < alchemyCount.min)
|
{
|
alchemyCount.min = min;
|
m_AlchemyCounts[config.AlchemyQuality] = alchemyCount;
|
}
|
if (max > alchemyCount.max)
|
{
|
alchemyCount.max = max;
|
m_AlchemyCounts[config.AlchemyQuality] = alchemyCount;
|
}
|
}
|
else
|
{
|
m_AlchemyCounts[config.AlchemyQuality] = new AlchemyCount()
|
{
|
min = min,
|
max = max,
|
};
|
}
|
}
|
}
|
|
{
|
var funcConfig = FuncConfigConfig.Get("alchemySuccess");
|
alchemySuccRate = funcConfig.Numerical3;
|
|
var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical2);
|
foreach (var key in json.Keys)
|
{
|
var quality = int.Parse(key);
|
m_AlchemyQualityLucks.Add(quality, int.Parse(json[key].ToString()));
|
}
|
}
|
|
{
|
var configs = AlchemyConfig.GetValues();
|
foreach (var config in configs)
|
{
|
m_AlchemyMaterials.Add(config.ID, new List<Item>());
|
var dict = ConfigParse.GetDic<int, int>(config.Material);
|
foreach (var key in dict.Keys)
|
{
|
m_AlchemyMaterials[config.ID].Add(new Item()
|
{
|
id = key,
|
count = dict[key],
|
});
|
}
|
}
|
}
|
}
|
|
public bool TryGetAlchemyStartTime(int alchemyId, out uint tick)
|
{
|
return m_AlchemyTimes.TryGetValue(alchemyId, out tick);
|
}
|
|
public bool TryGetAlchemyCount(int alchemyId, out AlchemyCount alchemyCount)
|
{
|
var config = AlchemyConfig.Get(alchemyId);
|
if (config == null)
|
{
|
alchemyCount = default(AlchemyCount);
|
return false;
|
}
|
if (config.AlchemType == (int)AlchemyType.Fairy)
|
{
|
alchemyCount = AlchemyCount.one;
|
return true;
|
}
|
return m_AlchemyCounts.TryGetValue(config.AlchemyQuality, out alchemyCount);
|
}
|
|
public bool TryGetAlchemyMaterials(int alchemyId, out List<Item> items)
|
{
|
return m_AlchemyMaterials.TryGetValue(alchemyId, out items);
|
}
|
|
public float GetAlchemySuccRate(int alchemyId)
|
{
|
var config = AlchemyConfig.Get(alchemyId);
|
if (config == null)
|
{
|
return 0f;
|
}
|
if (config.AlchemType == (int)AlchemyType.Fairy)
|
{
|
return 10000f;
|
}
|
var itemConfig = ItemConfig.Get(config.AlchemItemID);
|
var luckValue = PlayerDatas.Instance.extersion.luckValue;
|
return GetAlchemySuccRate(stoveLevel, itemConfig.LV, luckValue);
|
}
|
|
public float GetAlchemySuccRate(int stoveLevel, int itemLevel, int luck)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue("alchemyLV", stoveLevel);
|
Equation.Instance.AddKeyValue("alchemyQuality", itemLevel);
|
Equation.Instance.AddKeyValue("curLuckValue", luck);
|
var qualityNeedLuck = m_AlchemyQualityLucks.ContainsKey(itemLevel) ? m_AlchemyQualityLucks[itemLevel] : 0;
|
Equation.Instance.AddKeyValue("qualityNeedLuck", qualityNeedLuck);
|
return Equation.Instance.Eval<float>(alchemySuccRate);
|
}
|
|
public bool IsGraspRecipe(int alchemyId)
|
{
|
return m_AlchemyTimes.ContainsKey(alchemyId);
|
}
|
|
public void ReceivePackage(HA3BF_tagMCPlayerStoveMsg package)
|
{
|
for (int i = 0; i < package.StoveCnt; i++)
|
{
|
var data = package.InfoList[i];
|
m_AlchemyTimes[(int)data.AlchemyID] = data.StartTime;
|
}
|
|
stoveLevel = package.StoveLV;
|
stoveExp = (int)package.StoveExp;
|
|
if (package.ItemID != 0)
|
{
|
if (package.ItemCnt > 0)//炼丹成功
|
{
|
|
}
|
else//炼丹失败
|
{
|
|
}
|
}
|
|
if (alchemyStateRefresh != null)
|
{
|
alchemyStateRefresh();
|
}
|
}
|
|
public override void UnInit()
|
{
|
}
|
}
|
|
public enum AlchemyType
|
{
|
Normal = 1,
|
Fairy = 2,
|
}
|
|
public struct AlchemyCount
|
{
|
public int min;
|
public int max;
|
|
public static readonly AlchemyCount one = new AlchemyCount()
|
{
|
min = 1,
|
max = 1,
|
};
|
}
|
}
|
