Removed NioTSO client and server

- NioTSO client isn't needed because we're using RayLib
- Added FreeSO's API server to handle most backend operations

server/tso.common/Model/DynamicTuning.cs

@@ -0,0 +1,148 @@
+using System.Collections.Generic;
+using System.IO;
+
+namespace FSO.Common.Model
+{
+    public class DynamicTuning
+    {
+        //global tuning:
+        // city -
+        //  0: terrain
+        //   0: forceSnow (0/1/null)
+        public static DynamicTuning Global;
+
+        //string type/iff, int table, int index.
+        public Dictionary<string, Dictionary<int, Dictionary<int, float>>> Tuning = new Dictionary<string, Dictionary<int, Dictionary<int, float>>>();
+        public const int CURRENT_VERSION = 0;
+        public int Version = CURRENT_VERSION;
+
+        public void SerializeInto(BinaryWriter writer)
+        {
+            writer.Write(CURRENT_VERSION);
+            writer.Write(Tuning.Count);
+            foreach (var type in Tuning)
+            {
+                writer.Write(type.Key);
+                writer.Write(type.Value.Count);
+                foreach (var table in type.Value)
+                {
+                    writer.Write(table.Key);
+                    writer.Write(table.Value.Count);
+                    foreach (var value in table.Value)
+                    {
+                        writer.Write(value.Key);
+                        writer.Write(value.Value);
+                    }
+                }
+            }
+        }
+
+        public DynamicTuning(IEnumerable<DynTuningEntry> entries)
+        {
+            foreach (var entry in entries)
+            {
+                AddTuning(entry);
+            }
+        }
+
+        public void AddTuning(DynTuningEntry entry)
+        {
+            Dictionary<int, Dictionary<int, float>> tables;
+            if (!Tuning.TryGetValue(entry.tuning_type, out tables))
+            {
+                tables = new Dictionary<int, Dictionary<int, float>>();
+                Tuning[entry.tuning_type] = tables;
+            }
+            Dictionary<int, float> data;
+            if (!tables.TryGetValue(entry.tuning_table, out data))
+            {
+                data = new Dictionary<int, float>();
+                tables[entry.tuning_table] = data;
+            }
+            data[entry.tuning_index] = entry.value;
+        }
+
+        public DynamicTuning(DynamicTuning old)
+        {
+            foreach (var type in Tuning)
+            {
+                var newType = new Dictionary<int, Dictionary<int, float>>();
+                foreach (var table in type.Value)
+                {
+                    var newTable = new Dictionary<int, float>();
+                    foreach (var value in table.Value)
+                    {
+                        newTable[value.Key] = value.Value;
+                    }
+                    newType[table.Key] = newTable;
+                }
+                Tuning[type.Key] = newType;
+            }
+        }
+
+        public DynamicTuning(BinaryReader reader)
+        {
+            Version = reader.ReadInt32();
+            var count = reader.ReadInt32();
+            for (int i=0; i<count; i++)
+            {
+                var key = reader.ReadString();
+                var count2 = reader.ReadInt32();
+                var newType = new Dictionary<int, Dictionary<int, float>>();
+                for (int j = 0; j < count2; j++)
+                {
+                    var key2 = reader.ReadInt32();
+                    var count3 = reader.ReadInt32();
+                    var newTable = new Dictionary<int, float>();
+                    for (int k=0; k<count3; k++)
+                    {
+                        var key3 = reader.ReadInt32();
+                        newTable[key3] = reader.ReadSingle();
+                    }
+                    newType[key2] = newTable;
+                }
+                Tuning[key] = newType;
+            }
+        }
+
+        public Dictionary<int, float> GetTable(string type, int table)
+        {
+            Dictionary<int, Dictionary<int, float>> tables;
+            if (Tuning.TryGetValue(type, out tables))
+            {
+                Dictionary<int, float> data;
+                if (tables.TryGetValue(table, out data))
+                {
+                    return data;
+                }
+            }
+            return null;
+        }
+
+        public Dictionary<int, Dictionary<int, float>> GetTables(string type)
+        {
+            Dictionary<int, Dictionary<int, float>> tables;
+            if (Tuning.TryGetValue(type, out tables))
+            {
+                return tables;
+            }
+            return null;
+        }
+
+        public float? GetTuning(string type, int table, int index)
+        {
+            Dictionary<int, Dictionary<int, float>> tables;
+            if (Tuning.TryGetValue(type, out tables))
+            {
+                Dictionary<int, float> data;
+                if (tables.TryGetValue(table, out data))
+                {
+                    float result;
+                    if (data.TryGetValue(index, out result))
+                        return result;
+                }
+            }
+            return null;
+        }
+    }
+}