using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using UnityEngine;
|
|
|
public class Equation : Singleton<Equation>
|
{
|
public static readonly List<char> operatorList = new List<char>() { '*', '-', '+', '/', '^', '!', '@', '%', ';', '#', '$', '~', '&' };
|
|
public static StringBuilder textBuilder = new StringBuilder();
|
|
private List<KeyValuePair<string, string>> keyValueDic = new List<KeyValuePair<string, string>>();
|
|
public readonly Regex replaecRegex = new Regex(@"[a-zA-Z]{2,50}");
|
|
public T Eval<T>(string equation) where T : struct
|
{
|
keyValueDic.Sort(Compare);
|
equation = GetEquation(equation);
|
T val = default(T);
|
try
|
{
|
EquationParse equationParse = new EquationParse(equation);
|
val = (T)Convert.ChangeType(equationParse.result, typeof(T));
|
equationParse = null;
|
}
|
catch (Exception e)
|
{
|
Debug.LogError(e.Message);
|
}
|
return val;
|
}
|
|
private string GetEquation(string equation)
|
{
|
try
|
{
|
MatchCollection matchArray = replaecRegex.Matches(equation);
|
textBuilder.Length = 0;
|
int length = 0;
|
if (matchArray != null)
|
{
|
for (int i = 0; i < matchArray.Count; i++)
|
{
|
Match match = matchArray[i];
|
textBuilder.Append(equation.Substring(length, match.Index - length));
|
length = match.Index + match.Length;
|
bool _replace = false;
|
for (int j = 0; j < keyValueDic.Count; j++)
|
{
|
if (match.Value.Equals(keyValueDic[j].Key))
|
{
|
textBuilder.Append(keyValueDic[j].Value);
|
_replace = true;
|
break;
|
}
|
}
|
if (!_replace)
|
{
|
textBuilder.Append(0);
|
}
|
}
|
}
|
textBuilder.Append(equation.Substring(length, equation.Length - length));
|
}
|
catch (Exception e)
|
{
|
Debug.Log(e.Message);
|
}
|
return textBuilder.ToString();
|
}
|
|
public void AddKeyValue(string key, object val)
|
{
|
int index = keyValueDic.FindIndex((x) => {
|
return x.Key == key;
|
});
|
if (index == -1)
|
{
|
KeyValuePair<string, string> keyValuePair = new KeyValuePair<string, string>(key, val.ToString());
|
keyValueDic.Add(keyValuePair);
|
}
|
}
|
|
public void Clear()
|
{
|
keyValueDic.Clear();
|
}
|
|
int Compare(KeyValuePair<string, string> x, KeyValuePair<string, string> y)
|
{
|
return -x.Key.Length.CompareTo(y.Key.Length);
|
}
|
|
public class EquationParse
|
{
|
public string equation { get; private set; }
|
public string result { get; private set; }
|
private StringBuilder equationBuilder = new StringBuilder();
|
private List<EquationParse> subEquations = new List<EquationParse>();
|
private List<OperatorType> operatorTypeList = new List<OperatorType>();
|
private List<string> values = new List<string>();
|
public EquationParse(string _equation)
|
{
|
this.equation = _equation;
|
this.result = string.Empty;
|
equationBuilder.Length = 0;
|
if (CheckSplit())
|
{
|
return;
|
}
|
Subsection();
|
GetResult();
|
}
|
private bool CheckSplit()
|
{
|
var _left = string.Empty;
|
var _right = string.Empty;
|
OperatorType _operatorType;
|
if (Split(equation, out _left, out _right, out _operatorType))
|
{
|
var _leftResult = new EquationParse(_left);
|
var _rightResult = new EquationParse(_right);
|
result = GetResult(_leftResult.result, _rightResult.result, _operatorType).ToString();
|
return true;
|
}
|
return false;
|
}
|
private void Subsection()
|
{
|
try
|
{
|
int bracketCnt = 0;
|
int startIndex = 0;
|
int length = 0;
|
int index = 0;
|
for (int i = 0; i < equation.Length; i++)
|
{
|
if (equation[i] == '(')
|
{
|
i = i + 1;
|
startIndex = i;
|
while (i < equation.Length && (equation[i] != ')' || bracketCnt > 0))
|
{
|
if (equation[i] == '(')
|
{
|
bracketCnt++;
|
}
|
else if (equation[i] == ')')
|
{
|
bracketCnt--;
|
}
|
length++;
|
i = i + 1;
|
}
|
subEquations.Add(new EquationParse(equation.Substring(startIndex, length)));
|
length = 0;
|
equationBuilder.Append('=');
|
equationBuilder.Append(index);
|
equationBuilder.Append('=');
|
index++;
|
continue;
|
}
|
equationBuilder.Append(equation[i]);
|
}
|
}
|
catch (Exception e)
|
{
|
Debug.Log(e.Message);
|
}
|
}
|
|
private void AnalysisEquation()
|
{
|
try
|
{
|
textBuilder.Length = 0;
|
for (int i = 0; i < subEquations.Count; i++)
|
{
|
equationBuilder.Replace(string.Format("={0}=", i), subEquations[i].result);
|
subEquations[i] = null;
|
}
|
subEquations.Clear();
|
var _result = equationBuilder.ToString();
|
char _lastChar = default(char);
|
for (int i = 0; i < _result.Length; i++)
|
{
|
if (i - 1 > 0 && _result[i - 1] == 'E')
|
{//过滤超大数值后的符号
|
textBuilder.Append(_result[i]);
|
continue;
|
}
|
int index = operatorList.IndexOf(_result[i]);
|
if (index != -1 && _lastChar >= '0' && _lastChar <= '9')
|
{
|
values.Add(textBuilder.ToString());
|
textBuilder.Length = 0;
|
operatorTypeList.Add(GetOperatorType(_result[i]));
|
}
|
else
|
{
|
textBuilder.Append(_result[i]);
|
}
|
_lastChar = _result[i];
|
}
|
values.Add(textBuilder.ToString());
|
}
|
catch (Exception e)
|
{
|
Debug.Log(e.Message);
|
}
|
}
|
|
public void GetResult()
|
{
|
AnalysisEquation();
|
try
|
{
|
for (int i = 0; i < operatorTypeList.Count; i++)
|
{
|
if (IsPriorityOperator(operatorTypeList[i]))
|
{
|
double _result = 0;
|
if (IsUnaryOperator(operatorTypeList[i]))
|
{
|
_result = GetResult(values[i], string.Empty, operatorTypeList[i]);
|
}
|
else
|
{
|
_result = GetResult(values[i], values[i + 1], operatorTypeList[i]);
|
values.RemoveAt(i);
|
}
|
values.RemoveAt(i);
|
values.Insert(i, _result.ToString());
|
operatorTypeList.RemoveAt(i);
|
i--;
|
}
|
}
|
while (values.Count > 1 && operatorTypeList.Count > 0)
|
{
|
double _result = 0;
|
if (IsUnaryOperator(operatorTypeList[0]))
|
{
|
_result = GetResult(values[0], string.Empty, operatorTypeList[0]);
|
}
|
else
|
{
|
_result = GetResult(values[0], values[1], operatorTypeList[0]);
|
values.RemoveAt(0);
|
}
|
values.RemoveAt(0);
|
values.Insert(0, _result.ToString());
|
operatorTypeList.RemoveAt(0);
|
}
|
if (operatorTypeList.Count == 1 && IsUnaryOperator(operatorTypeList[0]))
|
{
|
result = GetResult(values[0], string.Empty, operatorTypeList[0]).ToString();
|
}
|
else
|
{
|
result = values[0];
|
}
|
}
|
catch (Exception e)
|
{
|
Debug.Log(e.Message);
|
}
|
}
|
|
public static double GetResult(string leftValue, string rightValue, OperatorType operatorType)
|
{
|
double _leftValue = 0, _rightValue = 0;
|
try
|
{
|
double.TryParse(leftValue, out _leftValue);
|
double.TryParse(rightValue, out _rightValue);
|
}
|
catch (Exception)
|
{
|
Debug.LogErrorFormat("字符串不能转为数值{0} {1}", leftValue, rightValue);
|
}
|
switch (operatorType)
|
{
|
case OperatorType.Plus:
|
return _leftValue + _rightValue;
|
case OperatorType.Subtract:
|
return _leftValue - _rightValue;
|
case OperatorType.Ride:
|
return _leftValue * _rightValue;
|
case OperatorType.Divide:
|
if (_rightValue == 0)
|
{
|
_rightValue = 1;
|
}
|
return _leftValue / _rightValue;
|
case OperatorType.Pow:
|
return Math.Pow(_leftValue, _rightValue);
|
case OperatorType.Min:
|
return Math.Min(_leftValue, _rightValue);
|
case OperatorType.Max:
|
return Math.Max(_leftValue, _rightValue);
|
case OperatorType.Remain:
|
return _leftValue % _rightValue;
|
case OperatorType.Random:
|
{
|
return UnityEngine.Random.Range((float)_leftValue, (float)_rightValue);
|
}
|
case OperatorType.Floor:
|
return Math.Floor(_leftValue);
|
case OperatorType.Ceil:
|
return Math.Ceiling((float)_leftValue);
|
case OperatorType.RandomInt:
|
{
|
return UnityEngine.Random.Range((int)_leftValue, (int)_rightValue);
|
}
|
case OperatorType.Sqrt:
|
return Math.Sqrt(_leftValue);
|
|
}
|
return 0;
|
}
|
public static OperatorType GetOperatorType(char _operator)
|
{
|
switch (_operator)
|
{
|
case '+':
|
return OperatorType.Plus;
|
case '-':
|
return OperatorType.Subtract;
|
case '*':
|
return OperatorType.Ride;
|
case '/':
|
return OperatorType.Divide;
|
case '^':
|
return OperatorType.Pow;
|
case '!':
|
return OperatorType.Min;
|
case '@':
|
return OperatorType.Max;
|
case '%':
|
return OperatorType.Remain;
|
case ';':
|
return OperatorType.Random;
|
case '#':
|
return OperatorType.Floor;
|
case '$':
|
return OperatorType.Ceil;
|
case '~':
|
return OperatorType.RandomInt;
|
case '&':
|
return OperatorType.Sqrt;
|
}
|
return OperatorType.Plus;
|
}
|
public static bool IsPriorityOperator(OperatorType operatorType)
|
{
|
if (operatorType == OperatorType.Plus || operatorType == OperatorType.Subtract)
|
{
|
return false;
|
}
|
return true;
|
}
|
public static bool IsUnaryOperator(OperatorType operatorType)
|
{
|
if (operatorType == OperatorType.Floor || operatorType == OperatorType.Ceil
|
|| operatorType == OperatorType.Sqrt)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
private static bool Split(string _source, out string _left, out string _right, out OperatorType _type)
|
{
|
_left = _right = string.Empty;
|
_type = OperatorType.Plus;
|
try
|
{
|
var _index = 0;
|
for (int i = _source.Length - 1; i >= 0; i--)
|
{
|
if (_source[i] == ')')
|
{
|
_index++;
|
continue;
|
}
|
else if (_source[i] == '(')
|
{
|
_index--;
|
continue;
|
}
|
if (IsSplitOperator(_source[i], out _type) && _index == 0)
|
{
|
_left = _source.Substring(0, i);
|
if (i + 1 < _source.Length)
|
{
|
_right = _source.Substring(i + 1);
|
}
|
return true;
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
Debug.Log(e.Message);
|
}
|
return false;
|
}
|
|
public static bool IsSplitOperator(char _char, out OperatorType _type)
|
{
|
var _index = operatorList.FindIndex((x) =>
|
{
|
return x == _char;
|
});
|
_type = OperatorType.Plus;
|
if (_index == -1)
|
{
|
return false;
|
}
|
_type = GetOperatorType(_char);
|
switch (_type)
|
{
|
case OperatorType.Floor:
|
case OperatorType.Ceil:
|
case OperatorType.Min:
|
case OperatorType.Max:
|
case OperatorType.Remain:
|
case OperatorType.Pow:
|
case OperatorType.Random:
|
case OperatorType.RandomInt:
|
case OperatorType.Sqrt:
|
return true;
|
}
|
return false;
|
}
|
}
|
|
public enum OperatorType
|
{
|
Plus,//+
|
Subtract,//-
|
Ride,//*
|
Divide,// /
|
Pow,// ^
|
Min,// !
|
Max,// @
|
Remain,// %
|
Random,
|
Floor,
|
Ceil,
|
RandomInt,
|
Sqrt
|
}
|
}
|
