Program.cs

using System.Text.Encodings.Web;
using System.Text.Json;
using CUE4Parse.Compression;
using CUE4Parse.Encryption.Aes;
using CUE4Parse.FileProvider;
using CUE4Parse.FileProvider.Objects;
using CUE4Parse.UE4.Localization;
using CUE4Parse.UE4.Objects.Core.Misc;
using CUE4Parse.UE4.Readers;
using CUE4Parse.UE4.Versions;
using Newtonsoft.Json;
using System.Text.RegularExpressions;

namespace GetValorantLocres
{
    internal class Program
    {
        static void Main(string[] args)
        {
#if DEBUG
            args =
            [
                @"C:\Riot Games\VALORANT\live\ShooterGame\Content\Paks\en_US_Text-WindowsClient.pak",
                $"{AppDomain.CurrentDomain.BaseDirectory}"
            ];
#endif

            if (args.Length != 2) 
            {
                Console.WriteLine("Usage: RadiantConnectAssetScraper <input_file> <output_directory>");
                return;
            }

            string input = args[0];
            string outputDirectory = args[1];

            if (!Directory.Exists(outputDirectory)) Directory.CreateDirectory(outputDirectory);

            string oodlePath = Path.Combine(outputDirectory, "oodle.dll");

            if (!File.Exists(oodlePath))
                OodleHelper.DownloadOodleDll(oodlePath);
            OodleHelper.Initialize(oodlePath);

            StreamedFileProvider provider = new(
                "ValorantLive", 
                new VersionContainer(
                    EGame.GAME_Valorant
                ), 
                StringComparer.OrdinalIgnoreCase
            );

            provider.RegisterVfs(input);
            provider.SubmitKey(new FGuid(), new FAesKey("0x4BE71AF2459CF83899EC9DC2CB60E22AC4B3047E0211034BBABE9D174C069DD6"));
            provider.Initialize();
            
            if (provider.Files.TryGetValue("ShooterGame/Content/Localization/Game/en-US/Game.locres", out GameFile? file))
            {
                using FArchive reader = file.CreateReader();
                FTextLocalizationResource localization = new (reader);
                string json = JsonConvert.SerializeObject(localization);
                
                File.WriteAllText(Path.Combine(outputDirectory, "localization.json"), json);

                Dictionary<string, Dictionary<string, string>>? dictionaryConversion = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(json);

                if (dictionaryConversion is null) return;

                Dictionary<string, Dictionary<string, string>> filteredAgents = GetAgents(dictionaryConversion);
                Dictionary<string, Dictionary<string, object>> parsedAgents = ParseAgentData(filteredAgents);
                File.WriteAllText(Path.Combine(outputDirectory, "agents-localization.json"), JsonConvert.SerializeObject(parsedAgents));

                Dictionary<string, string> parsedMaps = ParseMapData(dictionaryConversion);
                File.WriteAllText(Path.Combine(outputDirectory, "maps-localization.json"), JsonConvert.SerializeObject(parsedMaps));

                Dictionary<string, string> parsedGamePods = ParsePodData(dictionaryConversion);
                File.WriteAllText(Path.Combine(outputDirectory, "gamepods-localization.json"), JsonConvert.SerializeObject(parsedGamePods));

                Dictionary<int, string> parseRankTiers = RankParse(dictionaryConversion);
                File.WriteAllText(Path.Combine(outputDirectory, "ranks-localization.json"), JsonConvert.SerializeObject(parseRankTiers));
            }
            else Console.Error.WriteLine("Failed to find locres file.");

        }

        private static Dictionary<int, string> RankParse(Dictionary<string, Dictionary<string, string>> source)
        {
            SortedDictionary<int, string> tiers = [];

            KeyValuePair<string, Dictionary<string, string>> uiSocialStrings = source.FirstOrDefault(x =>
                string.Equals(x.Key, "UI_Social_strings", StringComparison.OrdinalIgnoreCase));
            if (uiSocialStrings.Value is null) return tiers.ToDictionary();

            foreach ((string key, string value) in uiSocialStrings.Value)
            {
                if (!key.StartsWith("CompetitiveTier")) continue;

                string tierKey = key.Replace("CompetitiveTier", "", StringComparison.OrdinalIgnoreCase);

                if (int.TryParse(tierKey, out int rankTier))
                {
                    if (rankTier > 20)
                        rankTier += 3;

                    tiers.TryAdd(rankTier, value);
                }
                else if (tierKey.StartsWith("Ascendant"))
                {
                    if (int.TryParse(tierKey.Replace("Ascendant", ""), out int subTier))
                        tiers.TryAdd(20 + subTier, value); // Ascendant 1-3 are 21-23
                }
            }

            return tiers.ToDictionary();
        }

        private static readonly Dictionary<string, string> AbilityParse = new()
        {
            { "Ability_1", "Ability1" },
            { "Ability1", "Ability1" },
            { "Ability_Q", "Ability1" },
            { "AbilityQ", "Ability1" },

            { "Ability_2", "Ability2" },
            { "Ability2", "Ability2" },
            { "Ability_E", "Ability2" },
            { "AbilityE", "Ability2" },

            { "Ability_4", "Grenade" },
            { "Ability4", "Grenade" },
            { "GrenadeAbility", "Grenade" },

            { "Ultimate", "Ultimate" },
            { "Ability_X", "Ultimate" },
            { "AbilityX", "Ultimate" }
        };

        private static Dictionary<string, Dictionary<string, object>> ParseAgentData(Dictionary<string, Dictionary<string, string>> source)
        {
            Dictionary<string, Dictionary<string, object>> result = [];

            foreach ((string agentCodeName, Dictionary<string, string> data) in source)
            {
                Dictionary<string, Dictionary<string, string?>> parsed = new()
                {
                    ["Ability1"] = new Dictionary<string, string?> { ["DisplayName"] = null, ["Description"] = null },
                    ["Ability2"] = new Dictionary<string, string?> { ["DisplayName"] = null, ["Description"] = null },
                    ["Grenade"] = new Dictionary<string, string?> { ["DisplayName"] = null, ["Description"] = null },
                    ["Ultimate"] = new Dictionary<string, string?> { ["DisplayName"] = null, ["Description"] = null }
                };

                foreach ((string key, string value) in data)
                {
                    string baseKey = Regex.Replace(key, "_(DisplayName|DisplayName_AllCaps|Description)$", "", RegexOptions.IgnoreCase);

                    if (!AbilityParse.TryGetValue(baseKey, out string? standardized)) continue;

                    if (key.EndsWith("Description", StringComparison.OrdinalIgnoreCase))
                        parsed[standardized]["Description"] = value;
                    else 
                        parsed[standardized]["DisplayName"] = value;
                }
                
                result.Add(data["DisplayName"], new Dictionary<string, object>
                {
                    {"CodeName", agentCodeName},
                    {"Description", data["Description"]},
                    {"Abilities", parsed}
                });
            }

            return result;
        }

        public static Dictionary<string, Dictionary<string, string>> GetAgents(Dictionary<string, Dictionary<string, string>> source)
        {
            Dictionary<string, Dictionary<string, string>> result = [];

            foreach (KeyValuePair<string, Dictionary<string, string>> parent in source)
            {
                if (parent.Key.Contains("Collection_Strings") ||
                    parent.Key.Contains("MeleeStringTable") ||
                    parent.Key.Contains("UI") ||
                    parent.Key.Contains("GameMode") ||
                    parent.Key.Contains("Character"))
                {
                    continue;
                }

                if (!parent.Value.Any(val
                        => val.Key.Contains("Ability_") ||
                           val.Key.Contains("Ability1_") ||
                           val.Key.Contains("Ability2_") ||
                           val.Key.Contains("Ability3_") ||
                           val.Key.Contains("Ultimate_")
                    )) continue;

                string newKey = parent.Key.Replace("_Strings", "").Replace("_StringTables", "").Replace("_StringTable", "");

                if (result.TryGetValue(newKey, out Dictionary<string, string>? value))
                    foreach (KeyValuePair<string, string> kvp in parent.Value)
                        value[kvp.Key] = kvp.Value;
                else
                    result[newKey] = new Dictionary<string, string>(parent.Value);
            }

            return result;
        }


        private static Dictionary<string, string> ParseMapData(Dictionary<string, Dictionary<string, string>> source)
        {
            Dictionary<string, string> result = [];
            
            foreach (KeyValuePair<string, string> data in source.Where(keyData => !keyData.Key.Contains("UI")).SelectMany(keyData => keyData.Value.Where(data => !data.Key.Contains("PlayerCard")).Where(data => !data.Key.Contains("PlayerTitle"))))
            {
                if (data.Key.Contains("QueueName", StringComparison.OrdinalIgnoreCase))
                    result[data.Key
                        .Replace("QueueName", "", StringComparison.OrdinalIgnoreCase)
                        .Replace("_", "")] = FirstCharToUpper(data.Value.ToLowerInvariant());
                else if (data.Key.Contains("Hurm", StringComparison.OrdinalIgnoreCase) && 
                         data.Key.Contains("DisplayName", StringComparison.OrdinalIgnoreCase) && 
                         !data.Key.Contains("AllCaps", StringComparison.OrdinalIgnoreCase))
                    result[data.Key
                        .Replace("HURM_", "", StringComparison.OrdinalIgnoreCase)
                        .Replace("HURM", "", StringComparison.OrdinalIgnoreCase)
                        .Replace("DisplayName", "", StringComparison.OrdinalIgnoreCase)
                        .Replace("_", "")] = FirstCharToUpper(data.Value.ToLowerInvariant());
            }

            return result;
        }

        private static Dictionary<string, string> ParsePodData(Dictionary<string, Dictionary<string, string>> source)
        {
            Dictionary<string, string> result = [];

            foreach (KeyValuePair<string, string> data in source.First(keyData => keyData.Key.Equals("UI_GamePodStrings", StringComparison.OrdinalIgnoreCase)).Value)
                result.Add(data.Key, data.Value);

            return result;
        }

        public static string FirstCharToUpper(string input) =>
            input switch
            {
                null => throw new ArgumentNullException(nameof(input)),
                "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
                _ => string.Concat(input[0].ToString().ToUpper(), input.AsSpan(1))
            };
    }
}