using LitJson;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text.RegularExpressions;
|
using UnityEngine;
|
|
public class ConfigParse
|
{
|
public enum SegStrType
|
{
|
Multiple,
|
KeyValue,
|
}
|
|
public static T? GetSegValue<T>(string msg, string key, SegStrType type) where T : struct
|
{
|
T? result = null;
|
switch (type)
|
{
|
case SegStrType.Multiple:
|
{
|
uint index = 0;
|
uint.TryParse(key, out index);
|
result = (T)Convert.ChangeType(GetMultipleStr(msg, index), typeof(T));
|
}
|
break;
|
case SegStrType.KeyValue:
|
{
|
result = (T)Convert.ChangeType(GetKeyValue(msg, key), typeof(T));
|
}
|
break;
|
}
|
return result;
|
}
|
|
public static string GetSegValue(string msg, string key, SegStrType type)
|
{
|
switch (type)
|
{
|
case SegStrType.Multiple:
|
{
|
uint index = 0;
|
uint.TryParse(key, out index);
|
return GetMultipleStr(msg, index);
|
}
|
case SegStrType.KeyValue:
|
{
|
return GetKeyValue(msg, key);
|
}
|
}
|
return string.Empty;
|
}
|
|
private static string GetMultipleStr(string msg, uint index)
|
{
|
string[] segs = GetMultipleStr(msg);
|
if (segs != null && index < segs.Length)
|
{
|
return segs[index];
|
}
|
return string.Empty;
|
}
|
|
public static T[] GetMultipleStr<T>(string msg) where T : struct
|
{
|
string[] segs = GetMultipleStr(msg);
|
if (segs != null && segs.Length > 0)
|
{
|
T[] array = new T[segs.Length];
|
for (int i = 0; i < segs.Length; i++)
|
{
|
array[i] = (T)Convert.ChangeType(segs[i], typeof(T));
|
}
|
return array;
|
}
|
return null;
|
}
|
|
public static string[] GetMultipleStr(string msg)
|
{
|
string[] segs = msg.Split('|');
|
if (segs.Length == 1 && segs[0].Equals(string.Empty)) return null;
|
return segs;
|
}
|
|
private static string GetKeyValue(string msg, string key)
|
{
|
string[] segs = GetMultipleStr(msg);
|
for (int i = 0; i < segs.Length; i++)
|
{
|
string[] pair = GetKeyValue(segs[i]);
|
if (pair.Length > 1)
|
{
|
if (!pair[0].Equals(key)) continue;
|
else return pair[1];
|
}
|
else continue;
|
}
|
return string.Empty;
|
}
|
|
private static string[] GetKeyValue(string msg)
|
{
|
return msg.Split('_');
|
}
|
|
public static T[] GetKeyValueKeys<T>(string msg) where T : struct
|
{
|
string[] segs = GetMultipleStr(msg);
|
if (segs != null && segs.Length > 0)
|
{
|
T[] array = new T[segs.Length];
|
for (int i = 0; i < segs.Length; i++)
|
{
|
string[] pair = GetKeyValue(segs[i]);
|
if (pair.Length > 1)
|
{
|
array[i] = (T)Convert.ChangeType(pair[0], typeof(T));
|
}
|
}
|
return array;
|
}
|
return null;
|
}
|
|
public static T[] GetKeyValueValues<T>(string msg) where T : struct
|
{
|
string[] segs = GetMultipleStr(msg);
|
if (segs != null && segs.Length > 0)
|
{
|
T[] array = new T[segs.Length];
|
for (int i = 0; i < segs.Length; i++)
|
{
|
string[] pair = GetKeyValue(segs[i]);
|
if (pair.Length > 1)
|
{
|
array[i] = (T)Convert.ChangeType(pair[1], typeof(T));
|
}
|
}
|
return array;
|
}
|
return null;
|
}
|
|
public static Dictionary<T, P> GetDic<T, P>(string msg)
|
{
|
Dictionary<T, P> dic = null;
|
string[] segs = GetMultipleStr(msg);
|
if (segs != null && segs.Length > 0)
|
{
|
dic = new Dictionary<T, P>();
|
for (int i = 0; i < segs.Length; i++)
|
{
|
string[] pair = GetKeyValue(segs[i]);
|
if (pair.Length > 1)
|
{
|
dic.Add((T)Convert.ChangeType(pair[0], typeof(T)), (P)Convert.ChangeType(pair[1], typeof(P)));
|
}
|
}
|
}
|
return dic;
|
}
|
|
public static string ServerStringTrim(string str)
|
{
|
if (!string.IsNullOrEmpty(str))
|
{
|
str = str.Replace("\0", "");
|
str = str.Replace("\x00", "");
|
return str;
|
}
|
else
|
{
|
return string.Empty;
|
}
|
}
|
|
//{'17':['63','6','27'],'65':['800'],'55':['139'],'19':['1000','2600','130']}
|
public static Regex userDataRegex = new Regex(@"'([0-9]+)':\[(.*?)\]", RegexOptions.Singleline);
|
public static Dictionary<int, List<int>> Analysis(string val)//正则表达式的字符串分割
|
{
|
string s = ServerStringTrim(val);
|
if (string.IsNullOrEmpty(s))
|
{
|
return null;
|
}
|
|
s = s.Replace(" ", string.Empty);
|
if (!userDataRegex.IsMatch(s))
|
{
|
return null;
|
}
|
else
|
{
|
Dictionary<int, List<int>> dics = new Dictionary<int, List<int>>();
|
foreach (Match match in userDataRegex.Matches(s))
|
{
|
int id = int.Parse(match.Groups[1].Value);
|
string str = match.Groups[2].Value;
|
string[] vals = str.Split(',');
|
List<int> list = new List<int>();
|
for (int i = 0; i < vals.Length; i++)
|
{
|
int intval = int.Parse(vals[i].Replace('\'', ' '));
|
list.Add(intval);
|
}
|
if (!dics.ContainsKey(id))
|
{
|
dics.Add(id, list);
|
}
|
}
|
return dics;
|
}
|
}
|
|
public static Dictionary<int, List<int>> ParseJsonDict(string jsonStr)
|
{
|
if (jsonStr == "{}" || string.IsNullOrEmpty(jsonStr))
|
{
|
return new Dictionary<int, List<int>>();
|
}
|
var dict = JsonMapper.ToObject<Dictionary<string, List<int>>>(jsonStr);
|
Dictionary<int, List<int>> result = new Dictionary<int, List<int>>();
|
|
foreach (var item in dict)
|
{
|
result[int.Parse(item.Key)] = item.Value;
|
}
|
|
return result;
|
}
|
|
public static Dictionary<int, int> ParseIntDict(string jsonStr)
|
{
|
if (jsonStr == "{}" || string.IsNullOrEmpty(jsonStr))
|
{
|
return new Dictionary<int, int>();
|
}
|
var dict = JsonMapper.ToObject<Dictionary<string, int>>(jsonStr);
|
Dictionary<int, int> result = new Dictionary<int, int>();
|
|
foreach (var item in dict)
|
{
|
result[int.Parse(item.Key)] = item.Value;
|
}
|
|
return result;
|
}
|
|
public static Dictionary<int, int[]> ParseIntArrayDict(string jsonStr)
|
{
|
if (jsonStr == "{}" || string.IsNullOrEmpty(jsonStr))
|
{
|
return new Dictionary<int, int[]>();
|
}
|
var dict = JsonMapper.ToObject<Dictionary<string, int[]>>(jsonStr);
|
Dictionary<int, int[]> result = new Dictionary<int, int[]>();
|
|
foreach (var item in dict)
|
{
|
result[int.Parse(item.Key)] = item.Value;
|
}
|
|
return result;
|
}
|
|
public static Dictionary<int, int[][]> ParseIntArray2Dict(string jsonStr)
|
{
|
if (jsonStr == "{}" || string.IsNullOrEmpty(jsonStr))
|
{
|
return new Dictionary<int, int[][]>();
|
}
|
var dict = JsonMapper.ToObject<Dictionary<string, int[][]>>(jsonStr);
|
Dictionary<int, int[][]> result = new Dictionary<int, int[][]>();
|
|
foreach (var item in dict)
|
{
|
result[int.Parse(item.Key)] = item.Value;
|
}
|
|
return result;
|
}
|
|
|
//万分率转为每个id对应的概率 [[万分概率，id1],[万分概率，id2]]
|
public static Dictionary<int, int> GetRateDict(int[][] rateArray)
|
{
|
Dictionary<int, int> dic = new Dictionary<int, int>();
|
//概率为 减去上一个概率的值即为当前ID概率
|
for (int i = 0;i< rateArray.Length; i++)
|
{
|
if (i > 0)
|
{
|
dic[rateArray[i][1]] = rateArray[i][0] - rateArray[i - 1][0];
|
}
|
else
|
{
|
dic[rateArray[i][1]] = rateArray[i][0];
|
}
|
}
|
|
return dic;
|
}
|
}
|
