garden_client/Assets/Script/Tool/Auxiliary.cs

using LitJson;
using DragonBones;

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;

using System;
using System.IO;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Net;
using System.Security.Cryptography;
using System.Runtime.Serialization.Formatters.Binary;

using System.Security;
using System.Security.Cryptography.Xml;

using System.Xml;
using UnityEngine.Advertisements;
using Random = UnityEngine.Random;
using Transform = UnityEngine.Transform;

public class Amount
{
    public static double 百 = 100;
    public static double 千 = 1000;
    public static double 万 = 10000;
    public static double 十万 = 100000;
    public static double 百万 = 1000000;
    public static double 千万 = 10000000;
    public static double 亿 = 100000000;
    public static double 十亿 = 1000000000;
    public static double 千亿 = 100000000000;
    public static double 万亿 = 1000000000000;
    public static double 千万亿 = 1000000000000000;
    public static double 万万亿 = 10000000000000000;
}

public class Auxiliary : Regist
{
    #region 变量

    public string String;

    public Font Font;
    public GameObject Go;
    public List<GameObject> GoList;
    public List<SpriteRenderer> SrList;

    public static bool AnyKeyUp;
    public static bool AnyKeyDown;
    public static Auxiliary Instance;

    public static MD5 MD5
    {
        get
        {
            if (_MD5 == null)
            {
                _MD5 = new MD5CryptoServiceProvider();
            }

            return _MD5;
        }
        set { _MD5 = value; }
    }

    public static DESCryptoServiceProvider Des
    {
        get
        {
            if (_Des == null)
            {
                _Des = new DESCryptoServiceProvider();
                _Des.IV = Encoding.UTF8.GetBytes("19283740");
                _Des.Key = Encoding.UTF8.GetBytes("93287123");
            }

            return _Des;
        }
        set { _Des = value; }
    }

    private static MD5 _MD5;
    private static DESCryptoServiceProvider _Des;

    #endregion

    public override bool RegistImmed()
    {
        if (base.RegistImmed())
        {
            return true;
        }

        enabled = true;

        return false;
    }

    private void Awake()
    {
        Instance = this;
    }

    private void Update()
    {
        #region 调试

        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Debug.Log(Initializer.Complete + " " + ManaServer.Complete + " " + ManaCenter.Complete);
            ManaDebug.Log(Initializer.Complete + " " + ManaServer.Complete + " " + ManaCenter.Complete);
        }

        if (Input.GetKeyDown(KeyCode.Z))
        {
            
        }

        if (Input.GetKeyDown(KeyCode.X))
        {
            
        }

        if (Input.GetKeyDown(KeyCode.C))
        {
            
        }

        if (Input.GetKeyDown(KeyCode.V))
        {
            
        }

        //if (Input.GetKeyDown(KeyCode.P))
        //{
        //    ManaData.Level += 20;
        //}

        //if (Input.GetKeyDown(KeyCode.O))
        //{
        //    for (int i = 0; i < ManaData.SkillList.Count; i++)
        //    {
        //        ManaData.SkillList[i].ReceiveCool(1, true, true);
        //    }
        //}

        //if (Input.GetKeyDown(KeyCode.I))
        //{
        //    ManaData.Coin += 1000;
        //    ManaData.Diamond += 1000;
        //}

        //if (Input.GetKeyDown(KeyCode.U))
        //{
        //    Data.SavePlayerConfig();
        //    Data.SaveXml();
        //}

        //if (Input.GetKeyDown(KeyCode.Y))
        //{
        //    Data.ResetPlayerConfig();
        //    Data.SaveXml();
        //}

        //if (Input.GetKeyDown(KeyCode.T))
        //{
        //    ManaData.Pause = !ManaData.Pause;
        //}

        #endregion

        #region 输入检测

        if (Input.GetKeyDown(KeyCode.Escape))
        {
            ManaMiniGame.Pause = true;

            Bubble.Show(Language.GetStr("Common", "QuitGame"), null, null, Application.Quit, () => { ManaMiniGame.Pause = false; });
        }

        if (AnyKeyUp)
        {
            if (Input.anyKey == false)
            {
                AnyKeyUp = false;
            }
        }

        if (Input.anyKeyDown)
        {
            AnyKeyDown = true;
        }
        
        if (AnyKeyDown)
        {
            if (Input.anyKey == false)
            {
                AnyKeyUp = true;
                AnyKeyDown = false;
            }
        }

        #endregion
    }


    public static byte[] GetMD5(object obj)
    {
        
        MemoryStream memoryStream = new MemoryStream();
        BinaryFormatter binaryFormatter = new BinaryFormatter();

        binaryFormatter.Serialize(memoryStream, obj);

        byte[] bytes = memoryStream.GetBuffer();

        memoryStream.Dispose();

        return MD5.ComputeHash(bytes);
    }


    public static void EncryptXml(XmlDocument doc)
    {
        EncryptedXml encryptedXml = new EncryptedXml();

        XmlElement xmlElement = doc.DocumentElement;

        byte[] bytes = encryptedXml.EncryptData(xmlElement, Des, false);

        EncryptedData encryptedData = new EncryptedData();

        encryptedData.Type = EncryptedXml.XmlEncElementUrl;

        encryptedData.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncDESUrl);

        encryptedData.CipherData.CipherValue = bytes;

        EncryptedXml.ReplaceElement(xmlElement, encryptedData, false);
    }

    public static void DecryptXml(XmlDocument doc)
    {
        EncryptedXml encryptedXml = new EncryptedXml();

        XmlElement encryptXmlElement = (XmlElement)doc.GetElementsByTagName("EncryptedData")[0];

        EncryptedData encryptedData = new EncryptedData();
        
        encryptedData.LoadXml(encryptXmlElement);

        byte[] bytes = encryptedXml.DecryptData(encryptedData, Des);

        encryptedXml.ReplaceData(encryptXmlElement, bytes);
    }


    public static byte[] Encrypt(string str)
    {
        byte[] bytes = Encoding.UTF8.GetBytes(str);
        byte[] encryptBytes = Des.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length);

        return encryptBytes;
    }

    public static byte[] ToBytes(string str)
    {
        string[] strings = str.Split(' ');

        byte[] bytes = new byte[strings.Length];

        for (int i = 0; i < bytes.Length; i++)
        {
            bytes[i] = byte.Parse(strings[i]);
        }

        return bytes;
    }


    public static string Decrypt(string str)
    {
        byte[] encryptBytes = ToBytes(str);
        byte[] decryptBytes = Des.CreateDecryptor().TransformFinalBlock(encryptBytes, 0, encryptBytes.Length);

        return Encoding.UTF8.GetString(decryptBytes);
    }

    public static string ToString(byte[] bytes)
    {
        StringBuilder strB = new StringBuilder();

        for (int i = 0; i < bytes.Length; i++)
        {
            if (i == bytes.Length - 1)
            {
                strB.Append(bytes[i]);
            }
            else
            {
                strB.Append(bytes[i] + " ");
            }
        }

        return strB.ToString();
    }


    public static void CompileDic(Transform tra, Dictionary<string, Transform> dic)
    {
        Transform[] transforms = tra.GetComponentsInChildren<Transform>(true);

        for (int i = 0; i < transforms.Length; i++)
        {
            if (dic.ContainsKey(transforms[i].name))
            {
                throw new Exception(transforms[i].name);
            }
            else
            {
                dic.Add(transforms[i].name, transforms[i]);
            }
        }
    }


    public static string GetStreamPath()
    {
        if (Application.isEditor)
        {
            return "file://" + Application.streamingAssetsPath;
        }
        else if (Application.platform == RuntimePlatform.IPhonePlayer)
        {
            return "file://" + Application.streamingAssetsPath;
        }
        else if (Application.isMobilePlatform)
        {
            return Application.streamingAssetsPath;
        }
        else
        {
            throw new Exception();
        }
    }


    public void DelayCall(UnityAction function, int frame)
    {
        StartCoroutine(IDelayCall(function, frame));
    }

    public void DelayCall(UnityAction function, float time)
    {
        StartCoroutine(IDelayCall(function, time));
    }


    public static IEnumerator IDelayCall(UnityAction function, int frame)
    {
        int count = 0;

        while (count < frame)
        {
            count++;

            yield return null;
        }

        function.Invoke();
    }

    public static IEnumerator IDelayCall(UnityAction function, float time)
    {
        yield return new WaitForSeconds(time);

        function.Invoke();
    }


    public static string FmlParse1(string str)
    {
        int index = 0;
        int openIndex = 0;
        bool flag = false;
        bool group = false;
        
        for (int i = 0; i < str.Length; i++)
        {
            if (group)
            {
                if (str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/')
                {
                    str = str.Replace(openIndex, i - 1, FmlParse2(str[index], str.Between(openIndex, index - 1), str.Between(index + 1, i - 1)));
                    
                    i = 0;
                    group = false;
                }
                else if (i == str.Length - 1)
                {
                    str = str.Replace(openIndex, i, FmlParse2(str[index], str.Between(openIndex, index - 1), str.Between(index + 1, i)));

                    break;
                }
            }
            else
            {
                if (str[i] == '+' || str[i] == '-')
                {
                    flag = true;
                    openIndex = i + 1;
                }
                else if (str[i] == '*' || str[i] == '/')
                {
                    index = i;
                    group = true;

                    if (!flag)
                    {
                        openIndex = 0;
                    }
                }
            }
        }

        group = false;

        for (int i = 0; i < str.Length; i++)
        {
            if (group)
            {
                if (str[i] == '+' || str[i] == '-')
                {
                    str = str.Replace(0, i - 1, FmlParse2(str[index], str.Between(0, index - 1), str.Between(index + 1, i - 1)));

                    i = -1;
                    group = false;
                }
                else if (i == str.Length - 1)
                {
                    return FmlParse2(str[index], str.Between(0, index - 1), str.Between(index + 1, i));
                }
            }
            else
            {
                if (str[i] == '+' || str[i] == '-')
                {
                    index = i;
                    group = true;
                }
            }
        }

        return str;
    }

    public static string FmlParse2(char op, string str1, string str2)
    {
        double var1 = double.Parse(str1);
        double var2 = double.Parse(str2);

        if (op == '+')
        {
            return (var1 + var2).ToString();
        }
        else if (op == '-')
        {
            return (var1 - var2).ToString();
        }
        else if (op == '*')
        {
            return (var1 * var2).ToString();
        }
        else if (op == '/')
        {
            return (var1 / var2).ToString();
        }
        else
        {
            throw new Exception(op.ToString());
        }
    }

    public static double FmlParse(string str, params string[] strings)
    {
        for (int i = 0; i < strings.Length; i += 2)
        {
            if (str.Contains(strings[i]))
            {
                str = str.Replace(strings[i], strings[i + 1]);
            }
            else
            {
                //Debug.Log("No such var " + strings[i + 1]);
            }
        }
        
        int openIndex = 0;

        for (int i = 0; i < str.Length; i++)
        {
            if (str[i] == '(')
            {
                openIndex = i;
            }
            else if (str[i] == ')')
            {
                str = str.Replace(openIndex, i, FmlParse1(str.Between(openIndex + 1, i - 1)));

                i = -1;
            }
        }
        
        return double.Parse(FmlParse1(str));
    }


    public static string OmitNumberStr(int accuray, string str)
    {
        int index = str.IndexOf('.');

        if (index == -1)
        {
            return str;
        }

        if (accuray == 0)
        {
            return str.Substring(0, index);
        }
        else
        {
            return str.Substring(0, index + accuray + 1);
        }
    }


    public static long ShrinkNumber(double value, int accuracy = 1)
    {
        long longValue = (long) value;
        
        if (ManaLan.CurrentLan == Lan.English)
        {
            if (longValue < Amount.千)
            {
                return longValue;
            }
            else if (longValue < Amount.百万)
            {
                long temp = (long) Amount.百;

                return (longValue/ temp) * temp;
            }
            else if (longValue < Amount.十亿)
            {
                long temp = (long)Amount.十万;

                return (longValue / temp) * temp;
            }
            else if (longValue < Amount.万亿)
            {
                long temp = (long)Amount.亿;

                return (longValue / temp) * temp;
            }
            else if (longValue < Amount.千万亿)
            {
                long temp = (long)Amount.千亿;

                return (longValue / temp) * temp;
            }
        }
        else if (ManaLan.CurrentLan == Lan.ChineseSimplified || ManaLan.CurrentLan == Lan.ChineseTraditional)
        {
            if (longValue < Amount.万)
            {
                return longValue;
            }
            else if (longValue < Amount.亿)
            {
                long temp = (long)Amount.千;

                return (longValue / temp) * temp;
            }
            else if (longValue < Amount.万亿)
            {
                long temp = (long)Amount.千万;

                return (longValue / temp) * temp;
            }
            else if (longValue < Amount.万万亿)
            {
                long temp = (long)Amount.千亿;

                return (longValue / temp) * temp;
            }
        }

        throw new Exception();
    }

    public static string ShrinkNumberStr(double value, int accuracy = 1)
    {
        long longValue = (long) value;

        if (ManaLan.CurrentLan == Lan.English)
        {
            if (longValue < Amount.千)
            {
                return longValue.ToString();
            }
            else if (longValue < Amount.百万)
            {
                string str = (longValue / Amount.千).ToString();

                return OmitNumberStr(accuracy, str) + "K";
            }
            else if (longValue < Amount.十亿)
            {
                string str = (longValue / Amount.百万).ToString();

                return OmitNumberStr(accuracy, str) + "M";
            }
            else if (longValue < Amount.万亿)
            {
                string str = (longValue / Amount.十亿).ToString();

                return OmitNumberStr(accuracy, str) + "B";
            }
            else if (longValue < Amount.千万亿)
            {
                string str = (longValue / Amount.万亿).ToString();

                return OmitNumberStr(accuracy, str) + "T";
            }
        }
        else if (ManaLan.CurrentLan == Lan.ChineseSimplified)
        {
            if (longValue < Amount.万)
            {
                return longValue.ToString();
            }
            else if (longValue < Amount.亿)
            {
                string str = (longValue/Amount.万).ToString();

                return OmitNumberStr(accuracy, str) + "万";
            }
            else if (longValue < Amount.万亿)
            {
                string str = (longValue / Amount.亿).ToString();

                return OmitNumberStr(accuracy, str) + "亿";
            }
            else if (longValue < Amount.万万亿)
            {
                string str = (longValue / Amount.万亿).ToString();

                return OmitNumberStr(accuracy, str) + "万亿";
            }
        }
        else if (ManaLan.CurrentLan == Lan.ChineseTraditional)
        {
            if (longValue < Amount.万)
            {
                return longValue.ToString();
            }
            else if (longValue < Amount.亿)
            {
                string str = (longValue / Amount.万).ToString();

                return OmitNumberStr(accuracy, str) + "萬";
            }
            else if (longValue < Amount.万亿)
            {
                string str = (longValue / Amount.亿).ToString();

                return OmitNumberStr(accuracy, str) + "億";
            }
            else if (longValue < Amount.万万亿)
            {
                string str = (longValue / Amount.万亿).ToString();

                return OmitNumberStr(accuracy, str) + "萬億";
            }
        }

        throw new Exception();
    }


    public static int IntParse(string str, int defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            return int.Parse(str);
        }
    }

    public static long LongParse(string str, long defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            return long.Parse(str);
        }
    }

    public static bool BoolParse(string str, bool defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            return Convert.ToBoolean(int.Parse(str));
        }
    }

    public static float FloatParse(string str, float defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            return float.Parse(str);
        }
    }

    public static double DoubleParse(string str, double defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            return float.Parse(str);
        }
    }

    public static List<int> IntListParse(char cah, string str, List<int> defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            string[] strings = str.Split(cah);

            List<int> list = new List<int>();

            for (int i = 0; i < strings.Length; i++)
            {
                list.Add(int.Parse(strings[i]));
            }

            return list;
        }
    }

    public static List<string> StringListParse(char cah, string str, List<string> defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            string[] strings = str.Split(cah);

            List<string> list = new List<string>();

            for (int i = 0; i < strings.Length; i++)
            {
                list.Add(strings[i]);
            }

            return list;
        }
    }

    public static List<double> DoubleListParse(char cah, string str, List<double> defaultValue)
    {
        if (string.IsNullOrEmpty(str))
        {
            return defaultValue;
        }
        else
        {
            string[] strings = str.Split(cah);

            List<double> list = new List<double>();

            for (int i = 0; i < strings.Length; i++)
            {
                list.Add(double.Parse(strings[i]));
            }

            return list;
        }
    }
}