Remove hardcoded server constants and use parsed constants from Server.m2d / constants.xml

Maple2.Database/Model/Mail.cs

@@ -55,7 +55,7 @@ internal class Mail {
 
     [return: NotNullIfNotNull(nameof(other))]
     public static implicit operator Maple2.Model.Game.Mail?(Mail? other) {
-        return other == null ? null : new Maple2.Model.Game.Mail {
+        return other == null ? null : new Maple2.Model.Game.Mail() {
             ReceiverId = other.ReceiverId,
             Id = other.Id,
             SenderId = other.SenderId,

Maple2.Database/Storage/Game/GameStorage.Map.cs

@@ -111,11 +111,11 @@ public IList<PlotCube> LoadCubesForOwner(long ownerId) {
             return Context.TrySaveChanges() ? ToPlotInfo(model) : null;
         }
 
-        public PlotInfo? GetSoonestPlotFromExpire() {
+        public PlotInfo? GetSoonestPlotFromExpire(TimeSpan ugcHomeSaleWaitingTime) {
             IQueryable<UgcMap> maps = Context.UgcMap.Where(map => map.ExpiryTime > DateTimeOffset.MinValue && !map.Indoor);
             foreach (UgcMap map in maps) {
                 if (map.OwnerId == 0) {
-                    map.ExpiryTime = map.ExpiryTime.Add(Constant.UgcHomeSaleWaitingTime);
+                    map.ExpiryTime = map.ExpiryTime.Add(ugcHomeSaleWaitingTime);
                 }
             }
             UgcMap? model = maps.OrderBy(map => map.ExpiryTime).FirstOrDefault();

Maple2.Database/Storage/Metadata/ServerTableMetadataStorage.cs

@@ -29,6 +29,7 @@ public class ServerTableMetadataStorage {
     private readonly Lazy<CombineSpawnTable> combineSpawnTable;
     private readonly Lazy<EnchantOptionTable> enchantOptionTable;
     private readonly Lazy<UnlimitedEnchantOptionTable> unlimitedEnchantOptionTable;
+    private readonly Lazy<ConstantsTable> constantsTable;
 
     public InstanceFieldTable InstanceFieldTable => instanceFieldTable.Value;
     public ScriptConditionTable ScriptConditionTable => scriptConditionTable.Value;
@@ -53,6 +54,7 @@ public class ServerTableMetadataStorage {
     public CombineSpawnTable CombineSpawnTable => combineSpawnTable.Value;
     public EnchantOptionTable EnchantOptionTable => enchantOptionTable.Value;
     public UnlimitedEnchantOptionTable UnlimitedEnchantOptionTable => unlimitedEnchantOptionTable.Value;
+    public ConstantsTable ConstantsTable => constantsTable.Value;
 
     public ServerTableMetadataStorage(MetadataContext context) {
         instanceFieldTable = Retrieve<InstanceFieldTable>(context, ServerTableNames.INSTANCE_FIELD);
@@ -78,6 +80,7 @@ public ServerTableMetadataStorage(MetadataContext context) {
         combineSpawnTable = Retrieve<CombineSpawnTable>(context, ServerTableNames.COMBINE_SPAWN);
         enchantOptionTable = Retrieve<EnchantOptionTable>(context, ServerTableNames.ENCHANT_OPTION);
         unlimitedEnchantOptionTable = Retrieve<UnlimitedEnchantOptionTable>(context, ServerTableNames.UNLIMITED_ENCHANT_OPTION);
+        constantsTable = Retrieve<ConstantsTable>(context, ServerTableNames.CONSTANTS);
     }
 
     public IEnumerable<GameEvent> GetGameEvents() {

Maple2.File.Ingest/Mapper/ServerTableMapper.cs

@@ -1,10 +1,10 @@
-using System.Globalization;
-using System.Xml;
-using Maple2.Database.Extensions;
+using Maple2.Database.Extensions;
 using Maple2.File.Ingest.Utils;
 using Maple2.File.IO;
 using Maple2.File.Parser;
 using Maple2.File.Parser.Enum;
+using Maple2.File.Parser.Flat.Convert;
+using Maple2.File.Parser.Xml.Table;
 using Maple2.File.Parser.Xml.Table.Server;
 using Maple2.Model;
 using Maple2.Model.Common;
@@ -13,6 +13,11 @@
 using Maple2.Model.Game;
 using Maple2.Model.Game.Shop;
 using Maple2.Model.Metadata;
+using Newtonsoft.Json.Linq;
+using System.Globalization;
+using System.Numerics;
+using System.Reflection;
+using System.Xml;
 using DayOfWeek = System.DayOfWeek;
 using ExpType = Maple2.Model.Enum.ExpType;
 using Fish = Maple2.File.Parser.Xml.Table.Server.Fish;
@@ -128,6 +133,10 @@ protected override IEnumerable<ServerTableMetadata> Map() {
             Name = ServerTableNames.UNLIMITED_ENCHANT_OPTION,
             Table = ParseUnlimitedEnchantOption(),
         };
+        yield return new ServerTableMetadata {
+            Name = ServerTableNames.CONSTANTS,
+            Table = ParseConstants(),
+        };
 
     }
 
@@ -2135,4 +2144,56 @@ void AddSpecial(Dictionary<SpecialAttribute, int> values, Dictionary<SpecialAttr
             }
         }
     }
+
+    private ConstantsTable ParseConstants() {
+        var constants = new ConstantsTable();
+        Dictionary<string, PropertyInfo> propertyLookup = typeof(ConstantsTable).GetProperties()
+            .ToDictionary(p => p.Name.Trim(), p => p, StringComparer.OrdinalIgnoreCase);
+        foreach ((string key, Constants.Key constant) in parser.ParseConstants()) {
+            string trimmedKey = key.Trim();
+            if (!propertyLookup.TryGetValue(trimmedKey, out PropertyInfo? property)) continue;
+            string cleanValue = CleanInput(constant.value.Trim(), trimmedKey, property.PropertyType);
+            GenericHelper.SetValue(property, constants, cleanValue);
+        }
+        return constants;
+
+        string CleanInput(string input, string propName, Type type) {
+            // check if string contains the ending 'f' for float designation, strip it if it does.
+            if (type == typeof(float) && input.Contains('f')) {
+                input = input.TrimEnd('f', 'F');
+            }
+            if (type == typeof(bool)) {
+                // 1 does not automatically equate to true during bool conversion
+                if (input == "1") {
+                    input = "true";
+                }
+                // 0 does not automatically equate to false during bool conversion
+                if (input == "0") {
+                    input = "false";
+                }
+            }
+            if (type == typeof(TimeSpan)) {
+                // Special case - dashes (-) are used instead of colons (:)
+                if (propName == "DailyTrophyResetDate") {
+                    input = input.Replace('-', ':');
+                }
+                // Stored as 0.1 for 100ms
+                if (propName == "GlobalCubeSkillIntervalTime") {
+                    input = $"0:0:{input}";
+                }
+                // Stored as an int value, convert to friendly input string for TimeSpan parsing
+                if (propName == "UgcHomeSaleWaitingTime") {
+                    int.TryParse(input, out int result);
+                    input = TimeSpan.FromSeconds(result).ToString(); // TODO: may not be correct conversion to TimeSpan
+                }
+            }
+            if (type == typeof(int)) {
+                // Remove prefix 0 on integers since they do not convert properly
+                if (input.Length > 1 && input[0] == '0') {
+                    input = input.Remove(0, 1);
+                }
+            }
+            return input;
+        }
+    }
 }

Maple2.File.Ingest/Utils/GenericHelper.cs

@@ -0,0 +1,103 @@
+using System.Globalization;
+using System.Numerics;
+using System.Reflection;
+
+namespace Maple2.File.Ingest.Utils;
+
+public static class GenericHelper {
+    public static void SetValue(PropertyInfo prop, object? obj, object? value) {
+        if (obj == null && value == null || value == null) return;
+        HandleNonIConvertibleTypes(prop, ref value);
+        if (value == null) return;
+        if (typeof(IConvertible).IsAssignableFrom(prop.PropertyType)) {
+            TryParseObject(prop.PropertyType, value, out object? result);
+            prop.SetValue(obj, result);
+            return;
+        }
+        prop.SetValue(obj, value);
+    }
+
+    private static object? HandleNonIConvertibleTypes(PropertyInfo prop, ref object? value) {
+        if (value == null) return value;
+        // Handle TimeSpan type
+        if (prop.PropertyType == typeof(TimeSpan)) {
+            TimeSpan.TryParse((string) value, CultureInfo.InvariantCulture, out TimeSpan val);
+            value = val;
+        }
+        // Handle array types (int[], short[], etc.)
+        if (prop.PropertyType.IsArray) {
+            var elementType = prop.PropertyType.GetElementType();
+            if (elementType == null) return value;
+            string[] segments = ((string) value).Split(',');
+            Array destinationArray = Array.CreateInstance(elementType, segments.Length);
+            for (int i = 0; i < segments.Length; i++) {
+                if (TryParseObject(elementType, segments[i].Trim(), out object? parseResult)) {
+                    destinationArray.SetValue(parseResult ?? default, i);
+                }else {
+                    destinationArray.SetValue(elementType.IsValueType ? Activator.CreateInstance(elementType) : null, i);
+                }
+            }
+            value = destinationArray;
+        }
+        // Handle Vector3 type
+        if (prop.PropertyType == typeof(Vector3)) {
+            string[] parts = ((string) value).Split(',');
+            bool parseXSuccess = float.TryParse(parts[0], CultureInfo.InvariantCulture, out float x);
+            bool parseYSuccess = float.TryParse(parts[1], CultureInfo.InvariantCulture, out float y);
+            bool parseZSuccess = float.TryParse(parts[2], CultureInfo.InvariantCulture, out float z);
+            if (parts.Length != 3 || parseXSuccess && parseYSuccess && parseZSuccess) {
+                value = Vector3.Zero;
+            } else {
+                value = new Vector3(x, y, z);
+            }
+        }
+        return value;
+    }
+
+    private static bool TryParseObject(Type? elementType, object? input, out object? result) {
+        if (elementType == null || input == null) {
+            result = null;
+            return false;
+        }
+
+        string inputString = Convert.ToString(input, CultureInfo.InvariantCulture)!;
+
+        // No TryParse method exists for a string, use the result directly.
+        if (elementType == typeof(string)) {
+            result = inputString;
+            return true;
+        }
+
+        Type[] argTypes = {
+        typeof(string),
+        typeof(IFormatProvider),
+        elementType.MakeByRefType()
+        };
+
+        var method = elementType.GetMethod("TryParse",
+            BindingFlags.Public | BindingFlags.Static,
+            null, argTypes, null);
+        if (method != null) {
+            object[] args = [inputString, CultureInfo.InvariantCulture, null!];
+            bool success = (bool) method.Invoke(null, args)!;
+            result = args[2];
+            return success;
+        }
+
+        // Fallback without CultureInfo provided, in case the type does not have a CultureInfo overload.
+        Type[] simpleArgs = { typeof(string), elementType.MakeByRefType() };
+        method = elementType.GetMethod("TryParse",
+            BindingFlags.Public | BindingFlags.Static,
+            null, simpleArgs, null);
+        if (method != null) {
+            object[] args = { inputString, null! };
+            bool success = (bool) method.Invoke(null, args)!;
+            result = args[1];
+            return success;
+        }
+
+
+        result = null;
+        return false;
+    }
+}

Maple2.Model/Common/ServerTableNames.cs

@@ -24,4 +24,5 @@ public static class ServerTableNames {
     public const string COMBINE_SPAWN = "combineSpawn*.xml";
     public const string ENCHANT_OPTION = "enchantOption.xml";
     public const string UNLIMITED_ENCHANT_OPTION = "unlimitedEnchantOption.xml";
+    public const string CONSTANTS = "constants.xml";
 }

Maple2.Model/Game/Cube/Nurturing.cs

@@ -48,20 +48,20 @@ public Nurturing(long exp, short claimedGiftForStage, long[] playedBy, DateTimeO
         }
     }
 
-    public void Feed() {
+    public void Feed(int nurturingEatGrowth) {
         if (Exp >= NurturingMetadata.RequiredGrowth.Last().Exp) {
             return;
         }
 
-        Exp += Constant.NurturingEatGrowth;
+        Exp += nurturingEatGrowth;
         if (Exp >= NurturingMetadata.RequiredGrowth.First(x => x.Stage == Stage).Exp) {
             Stage++;
         }
         LastFeedTime = DateTimeOffset.Now;
     }
 
-    public bool Play(long accountId) {
-        if (PlayedBy.Count >= Constant.NurturingPlayMaxCount) {
+    public bool Play(long accountId, int nurturingEatGrowth, int nurturingPlayMaxCount) {
+        if (PlayedBy.Count >= nurturingPlayMaxCount) {
             return false;
         }
 
@@ -70,7 +70,7 @@ public bool Play(long accountId) {
         }
 
         PlayedBy.Add(accountId);
-        Feed();
+        Feed(nurturingEatGrowth);
         return true;
     }
 

Maple2.Model/Game/Mail.cs

@@ -1,6 +1,5 @@
 using System.Text;
 using Maple2.Model.Enum;
-using Maple2.Model.Metadata;
 using Maple2.PacketLib.Tools;
 using Maple2.Tools;
 using Maple2.Tools.Extensions;
@@ -35,11 +34,19 @@ public class Mail : IByteSerializable {
     // More than 1 item may not display properly
     public readonly IList<Item> Items;
 
+    // Specifically for Mail object cloning (Mail.cs:57)
     public Mail() {
         TitleArgs = new List<(string Key, string Value)>();
         ContentArgs = new List<(string Key, string Value)>();
         Items = new List<Item>();
-        ExpiryTime = DateTimeOffset.UtcNow.AddDays(Constant.MailExpiryDays).ToUnixTimeSeconds();
+        // ExpiryTime will be overwritten, no need to set it here with a parameter passing server constant value.
+    }
+
+    public Mail(int mailExpiryDays) {
+        TitleArgs = new List<(string Key, string Value)>();
+        ContentArgs = new List<(string Key, string Value)>();
+        Items = new List<Item>();
+        ExpiryTime = DateTimeOffset.UtcNow.AddDays(mailExpiryDays).ToUnixTimeSeconds();
     }
 
     public void Update(Mail other) {

Maple2.Model/Game/User/StatAttributes.cs

@@ -13,9 +13,9 @@ public class StatAttributes : IByteSerializable {
     public int TotalPoints => Sources.Count;
     public int UsedPoints => Allocation.Count;
 
-    public StatAttributes() {
+    public StatAttributes(IDictionary<string, int> statLimits) {
         Sources = new PointSources();
-        Allocation = new PointAllocation();
+        Allocation = new PointAllocation(statLimits);
     }
 
     public void WriteTo(IByteWriter writer) {
@@ -52,14 +52,15 @@ public void WriteTo(IByteWriter writer) {
 
     public class PointAllocation : IByteSerializable {
         private readonly Dictionary<BasicAttribute, int> points;
+        private readonly IDictionary<string, int> statLimits;
 
         public BasicAttribute[] Attributes => points.Keys.ToArray();
         public int Count => points.Values.Sum();
 
         public int this[BasicAttribute type] {
             get => points.GetValueOrDefault(type);
             set {
-                if (value < 0 || value > StatLimit(type)) {
+                if (value < 0 || value > StatLimit(type, statLimits)) {
                     return;
                 }
                 if (value == 0) {
@@ -71,19 +72,20 @@ public int this[BasicAttribute type] {
             }
         }
 
-        public PointAllocation() {
+        public PointAllocation(IDictionary<string, int> statLimits) {
             points = new Dictionary<BasicAttribute, int>();
+            this.statLimits = statLimits;
         }
 
-        public static int StatLimit(BasicAttribute type) {
+        public static int StatLimit(BasicAttribute type, IDictionary<string, int> statLimits) {
             return type switch {
-                BasicAttribute.Strength => Constant.StatPointLimit_str,
-                BasicAttribute.Dexterity => Constant.StatPointLimit_dex,
-                BasicAttribute.Intelligence => Constant.StatPointLimit_int,
-                BasicAttribute.Luck => Constant.StatPointLimit_luk,
-                BasicAttribute.Health => Constant.StatPointLimit_hp,
-                BasicAttribute.CriticalRate => Constant.StatPointLimit_cap,
-                _ => 0,
+                BasicAttribute.Strength => statLimits.GetValueOrDefault("StatPointLimit_str"),
+                BasicAttribute.Dexterity => statLimits.GetValueOrDefault("StatPointLimit_dex"),
+                BasicAttribute.Intelligence => statLimits.GetValueOrDefault("StatPointLimit_int"),
+                BasicAttribute.Luck => statLimits.GetValueOrDefault("StatPointLimit_luk"),
+                BasicAttribute.Health => statLimits.GetValueOrDefault("StatPointLimit_hp"),
+                BasicAttribute.CriticalRate => statLimits.GetValueOrDefault("StatPointLimit_cap"),
+                _ => 0
             };
         }