PROJECT REPORT // WORLDFIRSTKILL

// ServerCSV_ConvertData.cs: 메타 시트 다운로드 및 2차원 카탈로그 구축
public static async Task<bool> DownloadMetaSheetAsync()
{
    string csvText = await DownloadFileAsync(MasterSheetURL);
    if (string.IsNullOrEmpty(csvText)) return false;

    string[] lines = csvText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
    csvURLDict.Clear();
    _serverVersions.Clear();

    for (int i = 1; i < lines.Length; i++)
    {
        string[] columns = lines[i].Split(',');
        if (columns.Length < 4) continue;

        string csvDataTypeStr = columns[0].Trim();
        string attribute = columns[1].Trim();
        string version = columns[2].Trim();
        string link = columns[3].Trim();

        if (!Enum.TryParse(csvDataTypeStr, out CSVDataType csvDataType)) continue;

        // 2차원 딕셔너리에 URL 및 최신 서버 버전 등록
        csvURLDict.GetOrAdd(csvDataType)[attribute] = link;
        _serverVersions.GetOrAdd(csvDataType)[attribute] = version;
    }
    return true;
}

// ServerCSV_ConvertData.cs: 조건부 다운로드 루틴
foreach (var kvp in csvURLDict)
{
    CSVDataType dataType = kvp.Key;
    foreach (var attrKvp in kvp.Value)
    {
        string attribute = attrKvp.Key;
        string url = attrKvp.Value;

        string serverVersion = _serverVersions[dataType][attribute];
        string localVersion = _localVersions.TryGetValue(dataType, out var lAttr) 
            && lAttr.TryGetValue(attribute, out var lVer) ? lVer : "0";

        string fileName = $"{dataType}_{attribute}.csv";
        string localFilePath = Path.Combine(LocalDataPath, fileName);
        bool needsDownload = true;

        // 로컬에 파일이 있고 버전이 동일하면 다운로드 생략 (캐시 적재)
        if (File.Exists(localFilePath) && localVersion == serverVersion)
        {
            try {
                fileContent = File.ReadAllText(localFilePath);
                needsDownload = false;
            } catch {
                needsDownload = true;
            }
        }

        if (needsDownload)
        {
            fileContent = await DownloadFileAsync(url);
            File.WriteAllText(localFilePath, fileContent);
            if (!_localVersions.ContainsKey(dataType)) 
                _localVersions[dataType] = new Dictionary<string, string>();
            _localVersions[dataType][attribute] = serverVersion;
        }

        currentCount++;
        progressCallback?.Invoke((float)currentCount / totalCount);
    }
}
SaveLocalVersions();

// GameSeed.cs: 목적별 서브 스트림 도메인 격리
public enum Domain : uint
{
    Map = 1, Region = 2, Field = 3, Quest = 4, Dialog = 5, Reward = 6, Class = 7,
    Class_Melee = 100, Class_Dexterity = 101, Class_Magic = 102, Class_Support = 103,
    Skill_Melee = 200, Skill_Dexterity = 201, Skill_Magic = 202, Skill_Support = 203,
}

// GameSeed.cs: SplitMix64 기반 서브 시드 유도 함수
private static int DeriveSubSeed(int baseSeed, uint salt)
{
    unchecked
    {
        // STEP 1 & 2. 64비트 황금비 상수 가산 및 도메인 솔트 소수 승산
        ulong z = (ulong)((uint)baseSeed) + 0x9E3779B97F4A7C15UL + (ulong)((uint)salt * 0x85EBCA6B);

        // STEP 3. David Stafford Mix13 다단계 XOR-Shift & 64-bit 소수 승산
        z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9UL;
        z = (z ^ (z >> 27)) * 0x94D049BB133111EBUL;
        z = z ^ (z >> 31);

        // STEP 4. 부호 비트 소거를 통한 32-bit 양수 시드 보장
        return (int)(z & 0x7FFFFFFF);
    }
}

// GameSeed.cs: 과거 난수 소비 지점으로 스트림 강제 롤백
public static void RestoreFromSnapshot(int baseSeed, Dictionary<Domain, ulong> usageCounts)
{
    Init(baseSeed); // 서브 시드로 전체 도메인 재초기화

    foreach (var kv in usageCounts)
    {
        Domain d = kv.Key;
        ulong count = kv.Value;
        System.Random rng = new System.Random(DeriveSubSeed(baseSeed, (uint)d));

        // 저장 시점까지 소비되었던 횟수만큼 난수를 버림(Skip) 호출
        for (ulong i = 0; i < count; i++)
        {
            rng.Next();
        }

        domainRng[d] = rng;
        domainUsageCounts[d] = count;
    }
}

// SaveLoadManager.cs: 시드 토큰 빌드 및 복원 구현
private const int BASE_SEED_WIDTH = 10;
private const int COUNT_WIDTH = 3;
private const int DOMAIN_ID_WIDTH = 3;
private const int USAGE_WIDTH = 12;

public static string BuildSeedToken()
{
    int baseSeed = GameSeed.BaseSeed;
    Dictionary<GameSeed.Domain, ulong> usage = GameSeed.GetUsageSnapshot();

    string token = Pad(EncodeIntToUInt(baseSeed), BASE_SEED_WIDTH);

    List<GameSeed.Domain> domains = new List<GameSeed.Domain>((GameSeed.Domain[])Enum.GetValues(typeof(GameSeed.Domain)));
    domains.Sort((a, b) => (a).CompareTo(b));

    token += Pad((uint)domains.Count, COUNT_WIDTH);
    foreach (var d in domains)
    {
        ulong count = usage.GetValueOrDefault(d, 0UL);
        token += Pad((uint)d, DOMAIN_ID_WIDTH);
        token += Pad(count, USAGE_WIDTH);
    }
    return token;
}

public static bool RestoreSeedToken(string token)
{
    try
    {
        int idx = 0;
        if (token.Length < BASE_SEED_WIDTH + COUNT_WIDTH) return false;

        ulong baseSeedEncoded = ReadUInt(token, ref idx, BASE_SEED_WIDTH);
        int baseSeed = DecodeUlongToInt(baseSeedEncoded);

        uint count = (uint)ReadUInt(token, ref idx, COUNT_WIDTH);
        int expectedTotal = (BASE_SEED_WIDTH + COUNT_WIDTH) + (int)count * (USAGE_WIDTH + DOMAIN_ID_WIDTH);
        if (token.Length != expectedTotal) return false;

        Dictionary<GameSeed.Domain, ulong> usage = new Dictionary<GameSeed.Domain, ulong>();
        for (int i = 0; i < count; i++)
        {
            uint domIdU = (uint)ReadUInt(token, ref idx, DOMAIN_ID_WIDTH);
            ulong u = ReadUInt(token, ref idx, USAGE_WIDTH);
            if (Enum.IsDefined(typeof(GameSeed.Domain), domIdU))
            {
                usage[(GameSeed.Domain)domIdU] = u;
            }
        }

        GameSeed.RestoreFromSnapshot(baseSeed, usage);
        return true;
    }
    catch { return false; }
}