using System; 
 | 
using System.Collections; 
 | 
using System.Collections.Generic; 
 | 
using System.Text.RegularExpressions; 
 | 
using UnityEngine; 
 | 
public class WordAnalysis : TRichAnalysis<WordAnalysis> 
 | 
{ 
 | 
    public static Regex Word_Regex = new Regex(@"<Word (.*?)/>", RegexOptions.Singleline); 
 | 
  
 | 
    public static Regex Color_Start_Regex = new Regex(@"<color=#[0-9a-zA-Z]+>", RegexOptions.Singleline); 
 | 
    public static Regex Color_End_Regex = new Regex(@"</color>", RegexOptions.Singleline); 
 | 
    public static Regex Space_Regex = new Regex(@"<Space=([0-9]*)>", RegexOptions.Singleline); 
 | 
    public static Regex Size_Start_Regex = new Regex(@"<[Ss]ize=([0-9]+)>", RegexOptions.Singleline); 
 | 
    public static Regex Size_End_Regex = new Regex(@"</[Ss]ize>", RegexOptions.Singleline); 
 | 
  
 | 
    private static RichTextEventEnum eventType = RichTextEventEnum.TABLE; 
 | 
  
 | 
    private static int presentColor = 0; 
 | 
    private static bool hasColor = false; 
 | 
  
 | 
    public override string Analysis(string val, bool IsRich) 
 | 
    { 
 | 
        if (!Word_Regex.IsMatch(val)) 
 | 
        { 
 | 
            return val; 
 | 
        } 
 | 
        int index = 0; 
 | 
        m_StringBuilder.Length = 0; 
 | 
        foreach (Match match in Word_Regex.Matches(val)) 
 | 
        { 
 | 
            m_StringBuilder.Append(val.Substring(index, match.Index - index)); 
 | 
            AnalysisSplitEvent(match.Groups[1].Value); 
 | 
            index = match.Index + match.Length; 
 | 
        } 
 | 
        m_StringBuilder.Append(val.Substring(index, val.Length - index)); 
 | 
        return m_StringBuilder.ToString(); 
 | 
    } 
 | 
  
 | 
    public override string CalculateTextIndex(string val, int index) 
 | 
    { 
 | 
        return string.Empty; 
 | 
    } 
 | 
  
 | 
    private void AnalysisSplitEvent(string val) 
 | 
    { 
 | 
        string[] array = GetSplitEvent(val); 
 | 
        if (array.Length > 0) 
 | 
        { 
 | 
            foreach (var split_event in array) 
 | 
            { 
 | 
                AnalysisSplitData(split_event); 
 | 
            } 
 | 
        } 
 | 
    } 
 | 
  
 | 
    private void AnalysisSplitData(string val) 
 | 
    { 
 | 
  
 | 
        string[] array = GetSplitData(val); 
 | 
        if (array.Length > 0) 
 | 
        { 
 | 
            bool hasAnalysis = true; 
 | 
            hasColor = false; 
 | 
            displayDic.Clear(); 
 | 
            string result = string.Empty; 
 | 
            foreach (var split_data in array) 
 | 
            { 
 | 
                hasAnalysis = AnalysisSplitValue(split_data, ref result) && hasAnalysis; 
 | 
            } 
 | 
            if (hasAnalysis) 
 | 
            { 
 | 
                result = RichTextMgr.Inst.GetDisplay(eventType, displayDic); 
 | 
            } 
 | 
            if (hasColor) 
 | 
            { 
 | 
                var text = RichTextMgr.Inst.presentRichText; 
 | 
                int colorType = 0; 
 | 
                if (text != null) 
 | 
                { 
 | 
                    colorType = text.colorType == RichText.ColorType.Dark ? 0 : 1; 
 | 
                } 
 | 
                result = Color_Start_Regex.Replace(result, string.Empty); 
 | 
                result = Color_End_Regex.Replace(result, string.Empty); 
 | 
                result = UIHelper.AppendColor(presentColor, result, colorType == 1); 
 | 
            } 
 | 
            m_StringBuilder.Append(result); 
 | 
        } 
 | 
  
 | 
    } 
 | 
  
 | 
    private bool AnalysisSplitValue(string val, ref string result) 
 | 
    { 
 | 
        string[] array = GetSplitValue(val); 
 | 
        if (array.Length == 2) 
 | 
        { 
 | 
            string split_value = array[0].ToLower(); 
 | 
            switch (split_value) 
 | 
            { 
 | 
                case "info": 
 | 
                    { 
 | 
                        eventType = RichTextEventEnum.TABLE; 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                    } 
 | 
                    break; 
 | 
                case "show": 
 | 
                    { 
 | 
                        if (array[1].ToLower() == "null") 
 | 
                        { 
 | 
                            result = Language.Get("Market_Text_33"); 
 | 
                        } 
 | 
                        else 
 | 
                        { 
 | 
                            result = array[1]; 
 | 
                        } 
 | 
                        return false; 
 | 
                    } 
 | 
                case "color": 
 | 
                    { 
 | 
                        presentColor = int.Parse(array[1]); 
 | 
                        hasColor = true; 
 | 
                    } 
 | 
                    break; 
 | 
                case "exp": 
 | 
                    { 
 | 
                        ulong _exp = 0; 
 | 
                        ulong.TryParse(array[1], out _exp); 
 | 
                        result = UIHelper.ReplaceLargeNum(_exp); 
 | 
                        return false; 
 | 
                    } 
 | 
                case "time": 
 | 
                    { 
 | 
                        int _time = 0; 
 | 
                        int.TryParse(array[1], out _time); 
 | 
                        result = TimeUtility.SecondsToDHMSCHS(_time / 1000); 
 | 
                        return false; 
 | 
                    } 
 | 
                case "chatsend": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                    } 
 | 
                    break; 
 | 
                case "count": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                    } 
 | 
                    break; 
 | 
                case "ancientrobotname": 
 | 
                    { 
 | 
                        eventType = RichTextEventEnum.AncientRobotName; 
 | 
                    } 
 | 
                    break; 
 | 
                case "myfightpoint": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.MyFightPoint; 
 | 
                    } 
 | 
                    break; 
 | 
                case "myreikiroot": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.MyReikiRoot; 
 | 
                    } 
 | 
                    break; 
 | 
                case "mydefense": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.MyDefense; 
 | 
                    } 
 | 
                    break; 
 | 
                case "joblabel": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.JobLabel; 
 | 
                    } 
 | 
                    break; 
 | 
                case "blsos": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.BLSOS; 
 | 
                    } 
 | 
                    break; 
 | 
                case "gszd": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.GSZD; 
 | 
                    } 
 | 
                    break; 
 | 
                case "copy": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.COPY; 
 | 
                    } 
 | 
                    break; 
 | 
                case "serveridrangeinfo": 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1].ToLower()); 
 | 
                        eventType = RichTextEventEnum.XJDHServerIDRangeInfo; 
 | 
                    } 
 | 
                    break; 
 | 
                default: 
 | 
                    { 
 | 
                        displayDic.Add(split_value, array[1]); 
 | 
                    } 
 | 
                    break; 
 | 
            } 
 | 
            return true; 
 | 
        } 
 | 
        else 
 | 
        { 
 | 
            m_StringBuilder.Append(array[0]); 
 | 
            return false; 
 | 
        } 
 | 
    } 
 | 
  
 | 
    public string ReplaceSpace(string val) 
 | 
    { 
 | 
        m_StringBuilder.Length = 0; 
 | 
        if (!Space_Regex.IsMatch(val)) 
 | 
        { 
 | 
            return val; 
 | 
        } 
 | 
        int index = 0; 
 | 
        foreach (Match match in Space_Regex.Matches(val)) 
 | 
        { 
 | 
            m_StringBuilder.Append(val.Substring(index, match.Index - index)); 
 | 
            int spaceCnt = 0; 
 | 
            if (int.TryParse(match.Groups[1].Value, out spaceCnt)) 
 | 
            { 
 | 
                if (spaceCnt != 0) 
 | 
                { 
 | 
                    for (int i = 0; i < spaceCnt; i++) 
 | 
                    { 
 | 
                        m_StringBuilder.Append(UIHelper.no_breaking_space); 
 | 
                    } 
 | 
                } 
 | 
            } 
 | 
            index = match.Index + match.Length; 
 | 
        } 
 | 
        m_StringBuilder.Append(val.Substring(index, val.Length - index)); 
 | 
        return m_StringBuilder.ToString(); 
 | 
    } 
 | 
} 
 |