Added FSO.Files for use with the API server

Don't ask me. FreeSO is the prime example of dependency hell.

server/tso.files/HIT/Hitlist.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace FSO.Files.HIT
+{
+    /// <summary>
+    /// HLS refers to two binary formats that both define a list of IDs, known as a hitlist.
+    /// One format is a Pascal string with a 4-byte, little-endian length, representing a 
+    /// comma-seperated list of decimal values, or decimal ranges (e.g. "1025-1035"), succeeded 
+    /// by a single LF newline.
+    /// </summary>
+    public class Hitlist
+    {
+        private uint m_IDCount;
+        public List<uint> IDs; //variable length so it's easier to fill with ranges
+
+        /// <summary>
+        /// Creates a new hitlist.
+        /// </summary>
+        /// <param name="Filedata">The data to create the hitlist from.</param>
+        public Hitlist(byte[] Filedata)
+        {
+            Read(new MemoryStream(Filedata));
+        }
+
+        private void Read(Stream data)
+        {
+            BinaryReader Reader = new BinaryReader(data);
+
+            IDs = new List<uint>();
+            var VerOrCount = Reader.ReadUInt32();
+
+            try
+            {
+                if (VerOrCount == 1) //binary format, no hitlist is ever going to have length 1... (i hope)
+                {
+                    m_IDCount = Reader.ReadUInt32();
+
+                    for (int i = 0; i < m_IDCount; i++)
+                        IDs.Add(Reader.ReadUInt32());
+
+                    Reader.Close();
+                }
+                else
+                {
+                    var str = new string(Reader.ReadChars((int)VerOrCount));
+                    Populate(str);
+                }
+
+            }
+            catch
+            {
+                Reader.BaseStream.Seek(4, SeekOrigin.Begin); //attempt 3rd mystery format, count+int32
+                for (int i = 0; i < VerOrCount; i++)
+                    IDs.Add(Reader.ReadUInt32());
+            }
+        }
+
+        public Hitlist()
+        {
+            IDs = new List<uint>();
+        }
+
+        public void Populate(string str)
+        {
+            var commaSplit = str.Split(',');
+            for (int i = 0; i < commaSplit.Length; i++)
+            {
+                var dashSplit = commaSplit[i].Split('-');
+                if (dashSplit.Length > 1)
+                { //range, parse two values and fill in the gap
+                    var min = Convert.ToUInt32(dashSplit[0]);
+                    var max = Convert.ToUInt32(dashSplit[1]);
+                    for (uint j = min; j <= max; j++)
+                    {
+                        IDs.Add(j);
+                    }
+                }
+                else
+                { //literal entry, add to list
+                    IDs.Add(Convert.ToUInt32(commaSplit[i]));
+                }
+            }
+        }
+
+        public static Hitlist HitlistFromString(string str)
+        {
+            var result = new Hitlist();
+            result.Populate(str);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new hitlist.
+        /// </summary>
+        /// <param name="Filepath">The path to the hitlist to read.</param>
+        public Hitlist(string Filepath)
+        {
+            Read(File.Open(Filepath, FileMode.Open, FileAccess.Read, FileShare.Read));
+        }
+    }
+}