示例#1
0
 private static CommandLevel IterateInCommandTree(out string currentLocaleDesc, string[] parameterPath, Enum levelKey, CommandLevel currentLevel, int level)
 {
     if (currentLevel is null)
     {
         currentLocaleDesc = null;
         return(null);
     }
     if (level < parameterPath.Length - 1)
     {
         if (currentLevel.defaultValue != null)
         {
             Enum varType = currentLevel.defaultValue;
             try
             {
                 varType = (Enum)Enum.Parse(varType.GetType(), parameterPath[level]);
             }
             catch
             {
             }
             if (varType != currentLevel.defaultValue && currentLevel.nextLevelOptions.ContainsKey(varType))
             {
                 return(IterateInCommandTree(out currentLocaleDesc, parameterPath, varType, currentLevel.nextLevelOptions[varType], level + 1));
             }
         }
         else
         {
             if (!currentLevel.regexValidValues.IsNullOrWhiteSpace())
             {
                 if (Regex.IsMatch(parameterPath[level], $"^{currentLevel.regexValidValues}$"))
                 {
                     if (currentLevel.nextLevelByRegex != null)
                     {
                         return(IterateInCommandTree(out currentLocaleDesc, parameterPath, null, currentLevel.nextLevelByRegex, level + 1));
                     }
                 }
             }
         }
     }
     currentLocaleDesc = !(currentLevel.descriptionKey is null)
         ? currentLevel.descriptionKey
         : !(levelKey is null)
             ? CommandLevel.ToLocaleVar(levelKey)
             : !(currentLevel.defaultValue is null)
                 ? CommandLevel.ToLocaleVar(currentLevel.defaultValue)
                 : null;
     currentLevel.level = level;
     return(currentLevel);
 }
示例#2
0
        internal TextParameterVariableWrapper(string input, TextRenderingClass?renderingClass)
        {
            m_originalCommand = input;
            var parameterPath = CommandLevel.GetParameterPath(input);

            if (parameterPath.Length > 0)
            {
                VariableType varType = VariableType.Invalid;
                try
                {
                    varType = (VariableType)Enum.Parse(typeof(VariableType), parameterPath[0]);
                }
                catch { }
                if (!varType.Supports(renderingClass))
                {
                    return;
                }
                switch (varType)
                {
                case VariableType.SegmentTarget:
                    if (parameterPath.Length >= 3 && byte.TryParse(parameterPath[1], out byte targIdx) && targIdx <= 4)
                    {
                        try
                        {
                            if (Enum.Parse(typeof(VariableSegmentTargetSubType), parameterPath[2]) is VariableSegmentTargetSubType tt &&
                                tt.ReadData(parameterPath.Skip(3).ToArray(), ref subtype, ref numberFormat, ref stringFormat, ref prefix, ref suffix))
                            {
                                index = targIdx;
                                type  = VariableType.SegmentTarget;
                            }
                        }
                        catch { }
                    }
                    break;

                case VariableType.CurrentSegment:
                    if (parameterPath.Length >= 2)
                    {
                        try
                        {
                            if (Enum.Parse(typeof(VariableSegmentTargetSubType), parameterPath[1]) is VariableSegmentTargetSubType tt &&
                                tt.ReadData(parameterPath.Skip(2).ToArray(), ref subtype, ref numberFormat, ref stringFormat, ref prefix, ref suffix))
                            {
                                type = VariableType.CurrentSegment;
                            }
                        }
                        catch { }
                    }
                    break;

                case VariableType.CityData:
                    if (parameterPath.Length >= 2)
                    {
                        try
                        {
                            if (Enum.Parse(typeof(VariableCitySubType), parameterPath[1]) is VariableCitySubType tt &&
                                tt.ReadData(parameterPath.Skip(2).ToArray(), ref subtype, ref numberFormat, ref stringFormat, ref prefix, ref suffix))
                            {
                                type = VariableType.CityData;
                                break;
                            }
                        }
                        catch { }
                    }
                    break;

                case VariableType.CurrentBuilding:
                    if (parameterPath.Length >= 2)
                    {
                        try
                        {
                            if (Enum.Parse(typeof(VariableBuildingSubType), parameterPath[1]) is VariableBuildingSubType tt &&
                                tt.ReadData(parameterPath.Skip(2).ToArray(), ref subtype, ref numberFormat, ref stringFormat, ref prefix, ref suffix))
                            {
                                type = VariableType.CurrentBuilding;
                                break;
                            }
                        }
                        catch { }
                    }
                    break;

                case VariableType.CurrentVehicle:
                    if (parameterPath.Length >= 2)
                    {
                        try
                        {
                            if (Enum.Parse(typeof(VariableVehicleSubType), parameterPath[1]) is VariableVehicleSubType tt &&
                                tt.ReadData(parameterPath.Skip(2).ToArray(), ref subtype, ref numberFormat, ref stringFormat, ref prefix, ref suffix))
                            {
                                type = VariableType.CurrentBuilding;
                                break;
                            }
                        }
                        catch { }
                    }
                    break;
                }
            }
        }