using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using LitJson;
|
|
public class LegendPropertyUtility
|
{
|
static PropertyColor propertyColor;
|
static PropertyMap dogzPropertyMap;
|
static PropertyCount dogzPropertyCount;
|
static QualityPropertyValue dogzQualityPropertyValue;
|
static WingPropertyCount wingPropertyCount;
|
static WingPropertyValue wingPropertyValue;
|
|
public static void Init()
|
{
|
propertyColor = new PropertyColor("LegendAttrColor");
|
dogzPropertyMap = new PropertyMap(FuncConfigConfig.Get("DogzLegendAttrColor").Numerical1,
|
FuncConfigConfig.Get("DogzLegendAttrRulePreview").Numerical1);
|
dogzPropertyCount = new PropertyCount(FuncConfigConfig.Get("DogzLegendAttrCountPreview").Numerical1);
|
dogzQualityPropertyValue = new QualityPropertyValue(FuncConfigConfig.Get("DogzLegendAttrValueByColorPreview").Numerical1);
|
|
wingPropertyCount = new WingPropertyCount();
|
wingPropertyValue = new WingPropertyValue();
|
}
|
|
public static List<Int2> GetEquipProperties(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null)
|
{
|
return null;
|
}
|
|
var legendPropertyConfig = LegendPropertyValueConfig.Get(config.Type, config.LV, config.ItemColor, config.SuiteiD != 0);
|
if (legendPropertyConfig == null)
|
{
|
return null;
|
}
|
|
return new List<Int2>(legendPropertyConfig.previewValue);
|
}
|
|
public static int GetEquipPropertyCount(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null)
|
{
|
return 0;
|
}
|
|
var legendPropertyConfig = LegendPropertyValueConfig.Get(config.Type, config.LV, config.ItemColor, config.SuiteiD != 0);
|
if (legendPropertyConfig == null)
|
{
|
return 0;
|
}
|
|
return legendPropertyConfig.propertyCount;
|
}
|
|
public static string GetWingPropertyColor(int propertyId, int value)
|
{
|
return propertyColor.GetWingPropertyColor(propertyId, value);
|
}
|
|
public static LegendAttrType GetDogzPropertyType(int propertyId)
|
{
|
return dogzPropertyMap.GetPropertyType(propertyId);
|
}
|
|
public static bool HasDogzPlace(int place)
|
{
|
return dogzPropertyMap.HasPlace(place);
|
}
|
|
public static List<int> GetDogzPlaceProperties(int place)
|
{
|
return dogzPropertyMap.GetProperties(place);
|
}
|
|
public static int GetDogzPropertyCount(int quality, int star, LegendAttrType type)
|
{
|
return dogzPropertyCount.GetCount(quality, star, type);
|
}
|
|
public static int GetDogzQualityPropertyValue(int property, int quality)
|
{
|
return dogzQualityPropertyValue.GetValue(property, quality);
|
}
|
|
public static int GetWingPropertyCount(int level)
|
{
|
return wingPropertyCount.GetValue(level);
|
}
|
|
public static int GetWingPropertyMinValue(int level, int property)
|
{
|
return wingPropertyValue.GetMin(level, property);
|
}
|
|
public static int GetWingPropertyMaxValue(int level, int property)
|
{
|
return wingPropertyValue.GetMax(level, property);
|
}
|
|
public static bool HasWingProperties(int level)
|
{
|
return wingPropertyValue.Has(level);
|
}
|
|
public static List<int> GetWingProperties(int level)
|
{
|
return wingPropertyValue.GetProperties(level);
|
}
|
|
public static List<int> GetWingPropertyValues(int level, int property)
|
{
|
return wingPropertyValue.GetValues(level, property);
|
}
|
|
public class PropertyColor
|
{
|
Dictionary<int, Dictionary<int, string>> wingLegendPropertyColors = new Dictionary<int, Dictionary<int, string>>();
|
|
public PropertyColor(string configId)
|
{
|
var config = FuncConfigConfig.Get(configId);
|
|
var wingColorJsonData = JsonMapper.ToObject(config.Numerical2);
|
foreach (var key in wingColorJsonData.Keys)
|
{
|
var propertyId = int.Parse(key);
|
if (!wingLegendPropertyColors.ContainsKey(propertyId))
|
{
|
wingLegendPropertyColors[propertyId] = new Dictionary<int, string>();
|
}
|
|
var subJson = wingColorJsonData[key];
|
var colors = wingLegendPropertyColors[propertyId];
|
foreach (var key2 in subJson.Keys)
|
{
|
var limit = int.Parse(key2);
|
colors[limit] = subJson[key2][0].ToString();
|
}
|
}
|
|
}
|
|
public string GetWingPropertyColor(int propertyId, int value)
|
{
|
if (!wingLegendPropertyColors.ContainsKey(propertyId))
|
{
|
return "ffffff";
|
}
|
|
var colors = wingLegendPropertyColors[propertyId];
|
var ienumerator = colors.GetEnumerator();
|
ienumerator.MoveNext();
|
var color = ienumerator.Current.Value;
|
|
while (ienumerator.MoveNext())
|
{
|
if (value < ienumerator.Current.Key)
|
{
|
color = ienumerator.Current.Value;
|
}
|
else
|
{
|
break;
|
}
|
}
|
|
return color;
|
}
|
}
|
|
public class PropertyMap
|
{
|
Dictionary<int, LegendAttrType> propertyTypes = new Dictionary<int, LegendAttrType>();
|
// key 装备位 value 属性ID
|
Dictionary<int, List<int>> placeToProperties = new Dictionary<int, List<int>>();
|
|
public PropertyMap(string typeConfig, string placeConfig)
|
{
|
var json = JsonMapper.ToObject(typeConfig);
|
foreach (var item in json.Keys)
|
{
|
var type = (LegendAttrType)(int.Parse(item) - 1);
|
var propertyId = 0;
|
int.TryParse(json[item].ToString(), out propertyId);
|
propertyTypes[propertyId] = type;
|
}
|
|
json = JsonMapper.ToObject(placeConfig);
|
foreach (var key in json.Keys)
|
{
|
var equipPlace = int.Parse(key);
|
var properties = new List<int>();
|
placeToProperties.Add(equipPlace, properties);
|
|
if (json[key].IsArray)
|
{
|
var subJson = json[key];
|
for (var i = 0; i < subJson.Count; i++)
|
{
|
if (subJson[i].IsArray)
|
{
|
for (var j = 0; j < subJson[i].Count; j++)
|
{
|
var propertyId = (int)subJson[i][j];
|
properties.Add(propertyId);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
public bool HasProperty(int propertyId)
|
{
|
return propertyTypes.ContainsKey(propertyId);
|
}
|
|
public LegendAttrType GetPropertyType(int propertyId)
|
{
|
if (HasProperty(propertyId))
|
{
|
return propertyTypes[propertyId];
|
}
|
else
|
{
|
return LegendAttrType.Normal;
|
}
|
}
|
|
public bool HasPlace(int place)
|
{
|
return placeToProperties.ContainsKey(place);
|
}
|
|
public List<int> GetProperties(int place)
|
{
|
if (HasPlace(place))
|
{
|
return placeToProperties[place];
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
public List<int> GetProperties(int place, LegendAttrType type)
|
{
|
if (!HasPlace(place))
|
{
|
return null;
|
}
|
|
var allProperties = placeToProperties[place];
|
var properties = new List<int>();
|
for (var i = 0; i < allProperties.Count; i++)
|
{
|
var propertyId = allProperties[i];
|
if (propertyTypes[propertyId] == type)
|
{
|
properties.Add(propertyId);
|
}
|
}
|
|
return properties;
|
}
|
|
}
|
|
public class PropertyCount
|
{
|
Dictionary<int, StarPropertyCount> qualityToStarLegendPropertyCounts = new Dictionary<int, StarPropertyCount>();
|
|
public PropertyCount(string config)
|
{
|
var json = JsonMapper.ToObject(config);
|
foreach (var key in json.Keys)
|
{
|
var quality = int.Parse(key);
|
qualityToStarLegendPropertyCounts[quality] = new StarPropertyCount(json[key]);
|
}
|
}
|
|
public bool Has(int quality)
|
{
|
return qualityToStarLegendPropertyCounts.ContainsKey(quality);
|
}
|
|
public bool Has(int quality, int star)
|
{
|
if (!qualityToStarLegendPropertyCounts.ContainsKey(quality))
|
{
|
return false;
|
}
|
|
return qualityToStarLegendPropertyCounts[quality].Has(star);
|
}
|
|
public int GetCount(int quality, int star, LegendAttrType type)
|
{
|
if (!Has(quality, star))
|
{
|
return 0;
|
}
|
|
return qualityToStarLegendPropertyCounts[quality].GetCount(star, type);
|
}
|
|
class StarPropertyCount
|
{
|
Dictionary<int, Dictionary<LegendAttrType, int>> counts = new Dictionary<int, Dictionary<LegendAttrType, int>>();
|
|
public StarPropertyCount(JsonData json)
|
{
|
foreach (var key in json.Keys)
|
{
|
var star = int.Parse(key);
|
var typeCounts = counts[star] = new Dictionary<LegendAttrType, int>();
|
var subJson = json[key];
|
|
if (subJson.IsArray)
|
{
|
for (int i = 0; i < subJson.Count; i++)
|
{
|
var type = (LegendAttrType)(i);
|
typeCounts[type] = (int)subJson[i];
|
}
|
}
|
}
|
}
|
|
public bool Has(int star)
|
{
|
return counts.ContainsKey(star);
|
}
|
|
public int GetCount(int star, LegendAttrType type)
|
{
|
if (!counts.ContainsKey(star))
|
{
|
return 0;
|
}
|
|
if (!counts[star].ContainsKey(type))
|
{
|
return 0;
|
}
|
|
return counts[star][type];
|
}
|
|
}
|
}
|
|
public class QualityPropertyValue
|
{
|
// key 属性ID value 装备品质，属性数值
|
Dictionary<int, Dictionary<int, int>> qualityValues = new Dictionary<int, Dictionary<int, int>>();
|
|
public QualityPropertyValue(string config)
|
{
|
var json = JsonMapper.ToObject(config);
|
foreach (var key in json.Keys)
|
{
|
var propertyId = int.Parse(key);
|
var qualityToValue = new Dictionary<int, int>();
|
qualityValues.Add(propertyId, qualityToValue);
|
|
var subJson = json[key];
|
for (var i = 0; i < subJson.Count; i++)
|
{
|
qualityToValue[(int)subJson[i][0]] = (int)subJson[i][1];
|
}
|
}
|
}
|
|
public bool Has(int property)
|
{
|
return qualityValues.ContainsKey(property);
|
}
|
|
public bool Has(int property, int quality)
|
{
|
if (!qualityValues.ContainsKey(property))
|
{
|
return false;
|
}
|
|
return qualityValues[property].ContainsKey(property);
|
}
|
|
public int GetValue(int property, int quality)
|
{
|
if (Has(property, quality))
|
{
|
return qualityValues[property][quality];
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
}
|
|
public class WingPropertyCount
|
{
|
Dictionary<int, int> counts = new Dictionary<int, int>();
|
|
public WingPropertyCount()
|
{
|
var json = JsonMapper.ToObject(FuncConfigConfig.Get("WingLegendAttrCountPreview").Numerical1);
|
for (int i = 0; i < json.Count; i++)
|
{
|
counts[(int)json[i][0]] = (int)json[i][1];
|
}
|
}
|
|
public bool Has(int level)
|
{
|
return counts.ContainsKey(level);
|
}
|
|
public int GetValue(int level)
|
{
|
if (Has(level))
|
{
|
return counts[level];
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
}
|
|
public class WingPropertyValue
|
{
|
Dictionary<int, Dictionary<int, List<int>>> levelPropertyValues = new Dictionary<int, Dictionary<int, List<int>>>();
|
|
public WingPropertyValue()
|
{
|
var json = JsonMapper.ToObject(FuncConfigConfig.Get("WingLegendAttrValuePreview").Numerical1);
|
foreach (var key in json.Keys)
|
{
|
var levelValues = new Dictionary<int, List<int>>();
|
levelPropertyValues.Add(int.Parse(key), levelValues);
|
|
var subJson = json[key];
|
foreach (var propertyId in subJson.Keys)
|
{
|
var count = subJson[propertyId].Count;
|
var values = new List<int>();
|
levelValues[int.Parse(propertyId)] = values;
|
|
if (subJson[propertyId].IsArray)
|
{
|
for (var i = 0; i < subJson[propertyId].Count; i++)
|
{
|
values.Add((int)subJson[propertyId][i]);
|
}
|
}
|
|
}
|
}
|
}
|
|
public bool Has(int level)
|
{
|
return levelPropertyValues.ContainsKey(level);
|
}
|
|
public bool Has(int level, int propertyId)
|
{
|
if (!levelPropertyValues.ContainsKey(level))
|
{
|
return false;
|
}
|
|
return levelPropertyValues[level].ContainsKey(propertyId);
|
}
|
|
public int GetMin(int level, int propertyId)
|
{
|
if (Has(level, propertyId))
|
{
|
return levelPropertyValues[level][propertyId][0];
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
public int GetMax(int level, int propertyId)
|
{
|
if (Has(level, propertyId))
|
{
|
var count = levelPropertyValues[level][propertyId].Count;
|
return levelPropertyValues[level][propertyId][count - 1];
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
public List<int> GetProperties(int level)
|
{
|
if (Has(level))
|
{
|
return new List<int>(levelPropertyValues[level].Keys);
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
public List<int> GetValues(int level, int propertyId)
|
{
|
if (Has(level, propertyId))
|
{
|
return levelPropertyValues[level][propertyId];
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
}
|
}
|
