Regex pattern matching with multiple groups C#

It appears your file input is from a Solarus Quest Tileset data file. According to the specs:

This syntax of the tileset data file is actually valid Lua.

Rather than using Regex, consider using a Lua parser. NLua seems to be able to do a lot with Lua, although it may be a bit much for just parsing variable list notation.

See also: Easiest way to parse a Lua datastructure in C# / .Net

Your regex is really much more complex than it has to be... now only you and god know what it does - after a week only god will ;-)

Try this regex: tile_pattern\{(?:[^{}]|(?R))+\}

Please also make sure to set the correct flags (because I don't know the C# syntax for that)

• global (do not return after the first match)
• extended (ignore whitespaces)

Also refer to this sample https://regex101.com/r/zqcOBY/1

This also takes care of filtering future new elements in your file without the explicit exclude rules you define in your regex.

I went with a different solution

string[] patternString = Regex.Split(datFileString, "tile_pattern{");
            string[] borderString = Regex.Split(patternString[patternString.Length - 1], "border_set{");
            patternString[patternString.Length - 1] =
                patternString[patternString.Length - 1]
                    .Remove(patternString[patternString.Length - 1].IndexOf("border_set{", StringComparison.Ordinal));
            tilePatterns = new List<TilePatternData>();

            foreach (string s in patternString)
            {
                if (s.Contains("background_color")) continue;

                TilePatternData tilePatternData = new TilePatternData();
                tilePatternData.LoadFromDatFile(s);
                tilePatterns.Add(tilePatternData);
            }

Then in TilePatternData class

public void LoadFromDatFile(string datFileString)
        {
            //tile_pattern{
            //id = "10", (string)
            //ground = "empty", (string)
            //default_layer = 2, (number)
            //(x = 72,) (x = { 712, 728, 744 },) (number or table)(only matching the number, have to add in the table)
            //(y = 0,) (y = { 384, 384, 384 },) (number or table)(only matching the number, have to add in the table)
            //width = 8,
            //height = 16,
            //frame_delay = 250 (number, optional)
            //mirror_loop = true (boolean, optional)
            //scrolling (string, optional)(The Ones in the test file do not have a repeat_mode
            //repeat_mode = "none", (string, optional)
            //}

            Regex parts = new Regex("\\s*(\\w+)\\s*=\\s*\"(\\w+)\"");
            Match match = parts.Match(datFileString);
            //Debug.Log(match.Success + " " + datFileString);
            while (match.Success)
            {
                string pram = match.Groups[1].ToString();
                string value = match.Groups[2].ToString();
                // Debug.Log(pram + "=" + value);
                switch (pram)
                {
                    case "id":
                        id = value;
                        break;
                    case "ground":
                        Enum.TryParse(value, out ground);
                        break;
                    case "scrolling":
                        Debug.Log(pram + "=" + value);
                        Enum.TryParse(value, out scrollingEffect);
                        break;
                    case "repeat_mode":
                        Enum.TryParse(value, out repeatMode);
                        break;
                }

                match = match.NextMatch();
            }

            parts = new Regex("\\s*(\\w+)\\s*=\\s*(-*\\d+)");
            match = parts.Match(datFileString);
            // Debug.Log(match.Success + ": \\s*(\\w+)\\s*=\\s*(-*\\d+)");
            while (match.Success)
            {
                string pram = match.Groups[1].ToString();
                string value = match.Groups[2].ToString();
                // Debug.Log(pram + "=" + value);
                switch (pram)
                {
                    case "x":
                        int.TryParse(value, out startX);
                        break;
                    case "y":
                        int.TryParse(value, out startY);
                        break;
                    case "width":
                        int.TryParse(value, out width);
                        break;
                    case "height":
                        int.TryParse(value, out height);
                        break;
                    case "default_layer":
                        int.TryParse(value, out defaultLayer);
                        break;
                    case "frame_delay":
                        int.TryParse(value, out height);
                        break;
                }

                match = match.NextMatch();
            }

            // x = { 712, 728, 744 },
            parts = new Regex("\\s*([xy])\\s*=\\s*{(\\s*\\d+,*)*\\s*}");
            match = parts.Match(datFileString);
            Debug.Log(match.Success + ": \\s*([xy])\\s*=\\s*{(\\s*\\d+,*)*\\s*}");
            while (match.Success)
            {
                Debug.Log(match.Groups[2].Captures.Count);
                string pram = match.Groups[1].ToString();
                string[] value = new string[match.Groups[2].Captures.Count];
                // work in progress to extract the table values
            }

            parts = new Regex("\\s*mirror_loop\\s*=\\s*(\\w+)");
            match = parts.Match(datFileString);
            //Debug.Log(match.Success + ": \\s*mirror_loop\\s*=\\s*(\\w+)");
            if (!match.Success) return;
            bool.TryParse(match.Groups[1].ToString(), out mirrorLoop);
            Debug.Log(mirrorLoop);
        }

There may still be a way to simplify this even further.