mochaisvibecoded
1364 lines
56 KiB
C#
1364 lines
56 KiB
C#
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
using Mocha2023.Classes.DBs.DBClasses;
|
|
using static Mocha2023.Classes.DBs.DBClasses.RoomDBClasses;
|
|
|
|
namespace Mocha2023.Classes.DBs;
|
|
|
|
public static class ShowdownImporter
|
|
{
|
|
private const int CompatiblePersistenceVersion = 38;
|
|
private const int CompatibleUgcSubVersion = 0;
|
|
|
|
private static readonly JsonSerializerOptions JsonOptions = new()
|
|
{
|
|
PropertyNameCaseInsensitive = true,
|
|
AllowTrailingCommas = true,
|
|
ReadCommentHandling = JsonCommentHandling.Skip,
|
|
NumberHandling = JsonNumberHandling.AllowReadingFromString
|
|
};
|
|
|
|
public sealed record ImportResult(
|
|
long RoomId,
|
|
int SubRoomsImported,
|
|
int SavesImported,
|
|
int BlobsCopied,
|
|
int SavesSkipped,
|
|
string PlayableSubRoomName,
|
|
long PlayableSubRoomId)
|
|
{
|
|
public int BakedAssetsImported { get; init; }
|
|
public int AssetBundlesCopied { get; init; }
|
|
public int AssetBundlesMissing { get; init; }
|
|
public bool ImageCopied { get; init; }
|
|
public IReadOnlyList<string> UnityEngineVersions { get; init; } = Array.Empty<string>();
|
|
}
|
|
|
|
public static ImportResult ImportUnityMetadata(
|
|
string json,
|
|
long creatorAccountId = 1,
|
|
bool replaceExisting = true)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(json))
|
|
throw new InvalidDataException("The room metadata JSON is empty.");
|
|
|
|
using JsonDocument document = JsonDocument.Parse(json, new JsonDocumentOptions
|
|
{
|
|
AllowTrailingCommas = true,
|
|
CommentHandling = JsonCommentHandling.Skip
|
|
});
|
|
|
|
JsonElement root = document.RootElement;
|
|
foreach (string wrapper in new[] { "room", "Room", "value", "Value", "data", "Data" })
|
|
{
|
|
if (root.ValueKind == JsonValueKind.Object &&
|
|
TryGetProperty(root, wrapper, out JsonElement nested) &&
|
|
nested.ValueKind == JsonValueKind.Object)
|
|
{
|
|
root = nested;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ExportRoom exportRoom = JsonSerializer.Deserialize<ExportRoom>(
|
|
root.GetRawText(),
|
|
JsonOptions) ?? throw new InvalidDataException("Could not deserialize the room metadata JSON.");
|
|
|
|
return ImportUnityExport(exportRoom, creatorAccountId, replaceExisting);
|
|
}
|
|
|
|
public static ImportResult Import(
|
|
string exportRoot,
|
|
long creatorAccountId = 1,
|
|
bool replaceExisting = true)
|
|
{
|
|
exportRoot = Path.GetFullPath(exportRoot.Trim().Trim('"'));
|
|
string roomJsonPath = Path.Combine(exportRoot, "room.json");
|
|
|
|
if (!File.Exists(roomJsonPath))
|
|
throw new FileNotFoundException("room.json was not found.", roomJsonPath);
|
|
|
|
ExportRoom exportRoom = ReadJson<ExportRoom>(roomJsonPath);
|
|
if (string.IsNullOrWhiteSpace(exportRoom.Name))
|
|
throw new InvalidDataException("room.json does not contain a valid Name.");
|
|
|
|
string roomBlobDestination = Path.Combine(Program.dataDir, "CDN", "room");
|
|
string assetBundleDestination = Path.Combine(Program.dataDir, "CDN", "assetbundles");
|
|
string imageDestination = Path.Combine(Program.dataDir, "Images");
|
|
Directory.CreateDirectory(roomBlobDestination);
|
|
Directory.CreateDirectory(assetBundleDestination);
|
|
Directory.CreateDirectory(imageDestination);
|
|
|
|
string? assetBundleSource = FindDirectory(exportRoot, "AssetBundles");
|
|
|
|
long assignedRoomId = RoomDB.GetNextRoomId();
|
|
string normalizedRoomName = exportRoom.Name.Trim().TrimStart('^');
|
|
Room? existingByName = RoomDB.Rooms.FindAll().FirstOrDefault(room =>
|
|
string.Equals(room.Name, normalizedRoomName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (replaceExisting)
|
|
{
|
|
if (existingByName != null)
|
|
{
|
|
RoomDB.SubRoomDataSaves.DeleteMany(save => save.RoomId == existingByName.RoomId);
|
|
RoomDB.Rooms.Delete(existingByName.RoomId);
|
|
}
|
|
}
|
|
else if (existingByName != null)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"A room named \"{normalizedRoomName}\" already exists. Enable replaceExisting to overwrite it.");
|
|
}
|
|
|
|
long nextLocalSaveId = RoomDB.SubRoomDataSaves.Count() == 0
|
|
? 1
|
|
: Convert.ToInt64(RoomDB.SubRoomDataSaves.Max(save => save.SubRoomDataSaveId)) + 1;
|
|
|
|
var importedSubRooms = new List<SubRooms>();
|
|
int savesImported = 0;
|
|
int blobsCopied = 0;
|
|
int savesSkipped = 0;
|
|
int bakedAssetsImported = 0;
|
|
int assetBundlesCopied = 0;
|
|
int assetBundlesMissing = 0;
|
|
var unityEngineVersions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
SubRooms? playableSubRoom = null;
|
|
SubRoomDataSave? playableCurrentSave = null;
|
|
|
|
foreach (ExportSubRoom listedSubRoom in exportRoom.SubRooms ?? new List<ExportSubRoom>())
|
|
{
|
|
string subRoomDirectory = Path.Combine(exportRoot, listedSubRoom.SubRoomId.ToString());
|
|
string subRoomJsonPath = Path.Combine(subRoomDirectory, "subRoom.json");
|
|
if (!File.Exists(subRoomJsonPath))
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Missing subRoom.json for {listedSubRoom.SubRoomId}; skipped.");
|
|
continue;
|
|
}
|
|
|
|
ExportSubRoom sourceSubRoom = ReadJson<ExportSubRoom>(subRoomJsonPath);
|
|
MergeSubRoomMetadata(listedSubRoom, sourceSubRoom);
|
|
|
|
string savesDirectory = Path.Combine(subRoomDirectory, "Saves");
|
|
if (!Directory.Exists(savesDirectory))
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Missing Saves directory for {sourceSubRoom.SubRoomId}; skipped.");
|
|
continue;
|
|
}
|
|
|
|
var importedForThisSubRoom = new List<(long SourceSaveId, SubRoomDataSave LocalSave)>();
|
|
|
|
foreach (string saveDirectory in Directory.EnumerateDirectories(savesDirectory))
|
|
{
|
|
string directoryName = Path.GetFileName(saveDirectory);
|
|
string saveJsonPath = Path.Combine(saveDirectory, directoryName + ".json");
|
|
|
|
if (!File.Exists(saveJsonPath))
|
|
{
|
|
saveJsonPath = Directory.EnumerateFiles(saveDirectory, "*.json")
|
|
.FirstOrDefault(path =>
|
|
!Path.GetFileName(path).StartsWith(
|
|
"bakedUnityAsset-",
|
|
StringComparison.OrdinalIgnoreCase))
|
|
?? string.Empty;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(saveJsonPath) || !File.Exists(saveJsonPath))
|
|
{
|
|
savesSkipped++;
|
|
continue;
|
|
}
|
|
|
|
ExportSave sourceSave;
|
|
try
|
|
{
|
|
sourceSave = ReadJson<ExportSave>(saveJsonPath);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Invalid save JSON {saveJsonPath}: {exception.Message}");
|
|
savesSkipped++;
|
|
continue;
|
|
}
|
|
|
|
string safeBlobName = Path.GetFileName(sourceSave.DataBlob ?? string.Empty);
|
|
string sourceBlobPath = Path.Combine(saveDirectory, safeBlobName);
|
|
if (string.IsNullOrWhiteSpace(safeBlobName) || !File.Exists(sourceBlobPath))
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Missing blob for source save {sourceSave.SubRoomDataSaveId}; skipped.");
|
|
savesSkipped++;
|
|
continue;
|
|
}
|
|
|
|
string destinationBlobPath = Path.Combine(roomBlobDestination, safeBlobName);
|
|
if (CopyIfDifferent(sourceBlobPath, destinationBlobPath))
|
|
blobsCopied++;
|
|
|
|
var bakedAssets = new List<BakedUnityAsset>();
|
|
foreach (string bakedJsonPath in Directory.EnumerateFiles(
|
|
saveDirectory,
|
|
"bakedUnityAsset-*.json",
|
|
SearchOption.TopDirectoryOnly))
|
|
{
|
|
BakedUnityAsset? bakedAsset;
|
|
try
|
|
{
|
|
bakedAsset = ReadJson<BakedUnityAsset>(bakedJsonPath);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Invalid baked asset JSON {bakedJsonPath}: {exception.Message}");
|
|
continue;
|
|
}
|
|
|
|
bakedAsset.UnityAssetId = string.IsNullOrWhiteSpace(bakedAsset.UnityAssetId)
|
|
? sourceSave.UnityAssetId ?? string.Empty
|
|
: bakedAsset.UnityAssetId.Trim();
|
|
bakedAsset.Filename = Path.GetFileName(bakedAsset.Filename ?? string.Empty);
|
|
bakedAsset.UnityVersion = ParseUnityVersionFromMetadataName(Path.GetFileName(bakedJsonPath));
|
|
|
|
if (!string.IsNullOrWhiteSpace(bakedAsset.UnityVersion))
|
|
unityEngineVersions.Add(bakedAsset.UnityVersion);
|
|
|
|
if (string.IsNullOrWhiteSpace(bakedAsset.UnityAssetId) ||
|
|
string.IsNullOrWhiteSpace(bakedAsset.Filename))
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Baked asset metadata {bakedJsonPath} is missing an ID or filename.");
|
|
continue;
|
|
}
|
|
|
|
if (assetBundleSource == null)
|
|
{
|
|
bakedAsset.IsAvailable = false;
|
|
assetBundlesMissing++;
|
|
}
|
|
else
|
|
{
|
|
string sourceBundlePath = Path.Combine(assetBundleSource, bakedAsset.Filename);
|
|
string destinationBundlePath = Path.Combine(assetBundleDestination, bakedAsset.Filename);
|
|
if (!File.Exists(sourceBundlePath))
|
|
{
|
|
bakedAsset.IsAvailable = false;
|
|
assetBundlesMissing++;
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT] Missing asset bundle {bakedAsset.Filename} " +
|
|
$"for UnityAssetId={bakedAsset.UnityAssetId} target={bakedAsset.Target}.");
|
|
}
|
|
else
|
|
{
|
|
if (CopyIfDifferent(sourceBundlePath, destinationBundlePath))
|
|
assetBundlesCopied++;
|
|
|
|
string actualBundleHash = ComputeSha256Base64(destinationBundlePath);
|
|
if (!string.Equals(bakedAsset.Hash, actualBundleHash, StringComparison.Ordinal))
|
|
{
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT] Asset bundle hash normalized " +
|
|
$"file={bakedAsset.Filename} old={bakedAsset.Hash ?? "null"} " +
|
|
$"new={actualBundleHash}");
|
|
bakedAsset.Hash = actualBundleHash;
|
|
}
|
|
|
|
bakedAsset.IsAvailable = true;
|
|
}
|
|
}
|
|
|
|
bakedAssets.Add(bakedAsset);
|
|
bakedAssetsImported++;
|
|
}
|
|
|
|
string actualHash = ComputeSha256Base64(destinationBlobPath);
|
|
bool isSingleBlobBakedSave = !string.IsNullOrWhiteSpace(sourceSave.UnityAssetId);
|
|
var localSave = new SubRoomDataSave
|
|
{
|
|
SubRoomDataSaveId = nextLocalSaveId++,
|
|
RoomId = assignedRoomId,
|
|
SubRoomId = sourceSubRoom.SubRoomId,
|
|
SavedByAccountId = creatorAccountId,
|
|
DataBlob = safeBlobName,
|
|
RoomDataBlob = isSingleBlobBakedSave ? safeBlobName : null,
|
|
DataBlobHash = actualHash,
|
|
PersistenceVersion = NormalizePersistenceVersion(sourceSave.PersistenceVersion),
|
|
SavedOnPlatform = sourceSave.SavedOnPlatform,
|
|
SavedOnDeviceClass = sourceSave.SavedOnDeviceClass,
|
|
Description = sourceSave.Description,
|
|
CreatedAt = NormalizeCreatedAt(sourceSave.CreatedAt),
|
|
IsPublished = sourceSave.ModerationState != 0,
|
|
UnityAssetId = sourceSave.UnityAssetId,
|
|
ReferencedUnityAssetIds = sourceSave.ReferencedUnityAssetIds ?? new List<string>(),
|
|
OMVersion = RoomDB.NormalizeLegacyOMVersion(sourceSave.OMVersion),
|
|
UgcSubVersion = NormalizeUgcSubVersion(sourceSave.UgcSubVersion),
|
|
ModerationState = sourceSave.ModerationState,
|
|
Tags = sourceSave.Tags ?? new List<string>(),
|
|
BakedUnityAssets = bakedAssets
|
|
};
|
|
|
|
RoomDB.SubRoomDataSaves.Insert(localSave);
|
|
importedForThisSubRoom.Add((sourceSave.SubRoomDataSaveId, localSave));
|
|
savesImported++;
|
|
}
|
|
|
|
if (importedForThisSubRoom.Count == 0)
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT] Subroom {sourceSubRoom.Name} has no usable saves; skipped.");
|
|
continue;
|
|
}
|
|
|
|
long requestedCurrentSaveId = sourceSubRoom.CurrentSave?.SubRoomDataSaveId
|
|
?? listedSubRoom.CurrentSave?.SubRoomDataSaveId
|
|
?? 0;
|
|
|
|
(long SourceSaveId, SubRoomDataSave LocalSave) selectedItem =
|
|
importedForThisSubRoom.FirstOrDefault(item => item.SourceSaveId == requestedCurrentSaveId);
|
|
|
|
if (selectedItem.LocalSave == null)
|
|
{
|
|
selectedItem = importedForThisSubRoom
|
|
.OrderByDescending(item => item.LocalSave.CreatedAt)
|
|
.ThenByDescending(item => item.SourceSaveId)
|
|
.First();
|
|
}
|
|
|
|
SubRoomDataSave currentSave = selectedItem.LocalSave;
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT SELECT] subroom={sourceSubRoom.SubRoomId}:{sourceSubRoom.Name} " +
|
|
$"sourceSave={selectedItem.SourceSaveId} requested={requestedCurrentSaveId} " +
|
|
$"created={currentSave.CreatedAt:O} blob={currentSave.DataBlob} " +
|
|
$"persistence={currentSave.PersistenceVersion} " +
|
|
$"unityAsset={currentSave.UnityAssetId ?? "none"}");
|
|
|
|
int accessibilityValue = Enum.IsDefined(typeof(RoomAccessibility), sourceSubRoom.Accessibility)
|
|
? sourceSubRoom.Accessibility
|
|
: (int)RoomAccessibility.Public;
|
|
|
|
var localSubRoom = new SubRooms
|
|
{
|
|
SubRoomId = sourceSubRoom.SubRoomId,
|
|
RoomId = assignedRoomId,
|
|
Name = string.IsNullOrWhiteSpace(sourceSubRoom.Name) ? "Home" : sourceSubRoom.Name,
|
|
DataBlob = currentSave.DataBlob,
|
|
SubRoomDataSaveId = currentSave.SubRoomDataSaveId,
|
|
SubRoomDataSave = currentSave,
|
|
IsSandbox = sourceSubRoom.IsSandbox,
|
|
MaxPlayers = Math.Clamp(sourceSubRoom.MaxPlayers > 0 ? sourceSubRoom.MaxPlayers : 6, 1, 100),
|
|
Accessibility = (RoomAccessibility)accessibilityValue,
|
|
UnitySceneId = sourceSubRoom.UnitySceneId ?? string.Empty,
|
|
SavedByAccountId = creatorAccountId,
|
|
Permissions = new List<SubRoomPermission>()
|
|
};
|
|
|
|
importedSubRooms.Add(localSubRoom);
|
|
|
|
bool isNamedHome = string.Equals(localSubRoom.Name, "Home", StringComparison.OrdinalIgnoreCase);
|
|
bool isPublic = localSubRoom.Accessibility != RoomAccessibility.Private;
|
|
bool currentIsPublic = playableSubRoom == null ||
|
|
playableSubRoom.Accessibility != RoomAccessibility.Private;
|
|
if (playableSubRoom == null ||
|
|
(isPublic && !currentIsPublic) ||
|
|
(isPublic == currentIsPublic && isNamedHome))
|
|
{
|
|
playableSubRoom = localSubRoom;
|
|
playableCurrentSave = currentSave;
|
|
}
|
|
}
|
|
|
|
if (importedSubRooms.Count == 0 &&
|
|
exportRoom.SubRooms?.Any(subRoom => !string.IsNullOrWhiteSpace(subRoom.UnitySceneId)) == true)
|
|
{
|
|
return ImportUnityExport(exportRoom, creatorAccountId, replaceExisting: false);
|
|
}
|
|
|
|
if (importedSubRooms.Count == 0)
|
|
throw new InvalidDataException("No compatible save blobs or UnitySceneId subrooms could be imported.");
|
|
|
|
playableSubRoom ??= importedSubRooms[0];
|
|
playableCurrentSave ??= RoomDB.SubRoomDataSaves.FindById(playableSubRoom.SubRoomDataSaveId);
|
|
playableSubRoom.Name = "Home";
|
|
importedSubRooms.Remove(playableSubRoom);
|
|
importedSubRooms.Insert(0, playableSubRoom);
|
|
|
|
bool imageCopied = CopyRoomImage(exportRoot, exportRoom.ImageName, imageDestination, out string imageName);
|
|
int roomAccessibility = Enum.IsDefined(typeof(RoomAccessibility), exportRoom.Accessibility)
|
|
? exportRoom.Accessibility
|
|
: (int)RoomAccessibility.Public;
|
|
|
|
bool hasBakedAssets = importedSubRooms.Any(subRoom =>
|
|
RoomDB.SubRoomDataSaves.FindById(subRoom.SubRoomDataSaveId)?.BakedUnityAssets?.Count > 0);
|
|
|
|
var room = new Room
|
|
{
|
|
RoomId = assignedRoomId,
|
|
IsDorm = false,
|
|
MaxPlayerCalculationMode = 0,
|
|
MaxPlayers = Math.Clamp(
|
|
exportRoom.MaxPlayers > 0 ? exportRoom.MaxPlayers : playableSubRoom.MaxPlayers,
|
|
1,
|
|
100),
|
|
CloningAllowed = false,
|
|
DisableMicAutoMute = false,
|
|
DisableRoomComments = false,
|
|
EncryptVoiceChat = false,
|
|
ToxmodEnabled = true,
|
|
LoadScreenLocked = false,
|
|
PersistenceVersion = NormalizePersistenceVersion(
|
|
playableCurrentSave?.PersistenceVersion ?? exportRoom.PersistenceVersion),
|
|
AutoLocalizeRoom = false,
|
|
IsDeveloperOwned = true,
|
|
Name = exportRoom.Name.Trim().TrimStart('^'),
|
|
Description = string.IsNullOrWhiteSpace(exportRoom.Description)
|
|
? "Imported room export."
|
|
: exportRoom.Description,
|
|
ImageName = imageName,
|
|
WarningMask = 0,
|
|
CustomWarning = null,
|
|
CreatorAccountId = creatorAccountId,
|
|
State = RoomState.Active,
|
|
Accessibility = (RoomAccessibility)roomAccessibility,
|
|
SupportsLevelVoting = false,
|
|
IsRRO = false,
|
|
IsBaseRoom = false,
|
|
CreativeToolsBetaEnabled = hasBakedAssets,
|
|
SupportsScreens = true,
|
|
SupportsWalkVR = true,
|
|
SupportsTeleportVR = true,
|
|
SupportsVRLow = true,
|
|
SupportsQuest2 = true,
|
|
SupportsMobile = true,
|
|
SupportsJuniors = true,
|
|
MinLevel = 0,
|
|
CreatedAt = DateTime.UtcNow,
|
|
Stats = new Stats(),
|
|
RankedEntityId = assignedRoomId.ToString(),
|
|
RankingContext = null,
|
|
SubRooms = importedSubRooms,
|
|
Roles = new List<Roles>
|
|
{
|
|
new()
|
|
{
|
|
AccountId = creatorAccountId,
|
|
Role = Role.Creator,
|
|
InvitedRole = Role.None
|
|
}
|
|
},
|
|
|
|
DataBlob = playableCurrentSave?.RoomDataBlob,
|
|
UgcVersion = 1,
|
|
Tags = new List<Tags>(),
|
|
PromoImages = new List<string>(),
|
|
PromoExternalContent = new List<PromoExternalContent>(),
|
|
LoadScreens = new List<LoadScreens>()
|
|
};
|
|
|
|
if (!RoomDB.Rooms.Upsert(room))
|
|
throw new InvalidOperationException("LiteDB failed to upsert the imported room.");
|
|
|
|
Room? verifiedRoom = RoomDB.Rooms.FindById(room.RoomId);
|
|
if (verifiedRoom?.SubRooms == null || verifiedRoom.SubRooms.Count == 0)
|
|
throw new InvalidOperationException("The room was written, but LiteDB returned no subrooms after import.");
|
|
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT] Imported {room.Name} room={room.RoomId} " +
|
|
$"subrooms={importedSubRooms.Count} saves={savesImported} " +
|
|
$"bakedAssets={bakedAssetsImported} bundlesCopied={assetBundlesCopied} " +
|
|
$"bundlesMissing={assetBundlesMissing} playable={playableSubRoom.SubRoomId}:{playableSubRoom.Name}");
|
|
|
|
return new ImportResult(
|
|
room.RoomId,
|
|
importedSubRooms.Count,
|
|
savesImported,
|
|
blobsCopied,
|
|
savesSkipped,
|
|
playableSubRoom.Name,
|
|
playableSubRoom.SubRoomId)
|
|
{
|
|
BakedAssetsImported = bakedAssetsImported,
|
|
AssetBundlesCopied = assetBundlesCopied,
|
|
AssetBundlesMissing = assetBundlesMissing,
|
|
ImageCopied = imageCopied,
|
|
UnityEngineVersions = unityEngineVersions.OrderBy(value => value).ToArray()
|
|
};
|
|
}
|
|
|
|
private static readonly HttpClient DownloadClient = new()
|
|
{
|
|
Timeout = TimeSpan.FromMinutes(10)
|
|
};
|
|
|
|
public static async Task<ImportResult> ImportFromUrlAsync(
|
|
string rootUrl,
|
|
long creatorAccountId = 1,
|
|
bool replaceExisting = true,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(rootUrl) ||
|
|
!Uri.TryCreate(rootUrl, UriKind.Absolute, out Uri? rootUri) ||
|
|
(rootUri.Scheme != Uri.UriSchemeHttp && rootUri.Scheme != Uri.UriSchemeHttps))
|
|
{
|
|
throw new InvalidDataException("Enter a valid http:// or https:// URL to the room's own folder.");
|
|
}
|
|
|
|
string normalizedRoot = rootUrl.TrimEnd('/') + "/";
|
|
string importId = Guid.NewGuid().ToString("N");
|
|
string stagingRoot = Path.Combine(Program.dataDir, "Temp", "RoomImports", importId);
|
|
Directory.CreateDirectory(stagingRoot);
|
|
|
|
const long maxTotalBytes = 1024L * 1024L * 1024L;
|
|
const int maxSubRooms = 500;
|
|
const int maxSavesPerSubRoom = 500;
|
|
long totalDownloadedBytes = 0;
|
|
|
|
async Task DownloadFileAsync(string fileUrl, string destinationPath)
|
|
{
|
|
using HttpResponseMessage response = await DownloadClient.GetAsync(
|
|
fileUrl,
|
|
HttpCompletionOption.ResponseHeadersRead,
|
|
cancellationToken);
|
|
if (!response.IsSuccessStatusCode)
|
|
throw new InvalidDataException($"Could not download {fileUrl} ({(int)response.StatusCode}).");
|
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
|
|
await using Stream input = await response.Content.ReadAsStreamAsync(cancellationToken);
|
|
await using var output = new FileStream(
|
|
destinationPath,
|
|
FileMode.Create,
|
|
FileAccess.Write,
|
|
FileShare.None,
|
|
81920,
|
|
FileOptions.Asynchronous | FileOptions.SequentialScan);
|
|
|
|
byte[] buffer = new byte[81920];
|
|
while (true)
|
|
{
|
|
int read = await input.ReadAsync(buffer.AsMemory(0, buffer.Length), cancellationToken);
|
|
if (read == 0)
|
|
break;
|
|
|
|
totalDownloadedBytes += read;
|
|
if (totalDownloadedBytes > maxTotalBytes)
|
|
{
|
|
throw new InvalidDataException(
|
|
"This room's files add up to more than the 1 GiB limit for URL imports. " +
|
|
"Download it and use the ZIP import instead.");
|
|
}
|
|
|
|
await output.WriteAsync(buffer.AsMemory(0, read), cancellationToken);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
List<(string Name, bool IsDirectory)> rootEntries =
|
|
await ListRemoteDirectoryAsync(normalizedRoot, cancellationToken);
|
|
|
|
if (!rootEntries.Any(entry => !entry.IsDirectory &&
|
|
string.Equals(entry.Name, "room.json", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
throw new InvalidDataException(
|
|
"No room.json was found at that URL - point this at a room's own folder " +
|
|
"(the page that directly lists room.json and the subroom folders).");
|
|
}
|
|
|
|
await DownloadFileAsync(normalizedRoot + "room.json", Path.Combine(stagingRoot, "room.json"));
|
|
ExportRoom exportRoom = ReadJson<ExportRoom>(Path.Combine(stagingRoot, "room.json"));
|
|
|
|
if (!string.IsNullOrWhiteSpace(exportRoom.ImageName))
|
|
{
|
|
string imageFileName = Path.GetFileName(exportRoom.ImageName);
|
|
(string Name, bool IsDirectory) imageEntry = rootEntries.FirstOrDefault(entry =>
|
|
!entry.IsDirectory &&
|
|
string.Equals(entry.Name, imageFileName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (imageEntry.Name != null)
|
|
{
|
|
try
|
|
{
|
|
await DownloadFileAsync(
|
|
normalizedRoot + Uri.EscapeDataString(imageEntry.Name),
|
|
Path.Combine(stagingRoot, imageEntry.Name));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
Console.WriteLine($"[ROOM IMPORT URL] Could not fetch thumbnail: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
var referencedBundleFilenames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
int subRoomsFound = 0;
|
|
|
|
foreach ((string Name, bool IsDirectory) entry in rootEntries.Where(entry =>
|
|
entry.IsDirectory &&
|
|
!string.Equals(entry.Name, "AssetBundles", StringComparison.OrdinalIgnoreCase) &&
|
|
long.TryParse(entry.Name, out _)))
|
|
{
|
|
if (subRoomsFound >= maxSubRooms)
|
|
break;
|
|
|
|
string subRoomUrl = normalizedRoot + Uri.EscapeDataString(entry.Name) + "/";
|
|
List<(string Name, bool IsDirectory)> subRoomEntries =
|
|
await ListRemoteDirectoryAsync(subRoomUrl, cancellationToken);
|
|
|
|
if (!subRoomEntries.Any(e => !e.IsDirectory &&
|
|
string.Equals(e.Name, "subRoom.json", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
subRoomsFound++;
|
|
string localSubRoomDir = Path.Combine(stagingRoot, entry.Name);
|
|
await DownloadFileAsync(subRoomUrl + "subRoom.json", Path.Combine(localSubRoomDir, "subRoom.json"));
|
|
|
|
(string Name, bool IsDirectory) savesFolder = subRoomEntries.FirstOrDefault(e =>
|
|
e.IsDirectory && string.Equals(e.Name, "Saves", StringComparison.OrdinalIgnoreCase));
|
|
if (savesFolder.Name == null)
|
|
continue;
|
|
|
|
string savesUrl = subRoomUrl + "Saves/";
|
|
List<(string Name, bool IsDirectory)> saveEntries =
|
|
await ListRemoteDirectoryAsync(savesUrl, cancellationToken);
|
|
|
|
int savesForThisSubRoom = 0;
|
|
foreach ((string Name, bool IsDirectory) saveEntry in saveEntries.Where(e => e.IsDirectory))
|
|
{
|
|
if (savesForThisSubRoom >= maxSavesPerSubRoom)
|
|
break;
|
|
savesForThisSubRoom++;
|
|
|
|
string saveUrl = savesUrl + Uri.EscapeDataString(saveEntry.Name) + "/";
|
|
List<(string Name, bool IsDirectory)> saveFileEntries =
|
|
await ListRemoteDirectoryAsync(saveUrl, cancellationToken);
|
|
string localSaveDir = Path.Combine(localSubRoomDir, "Saves", saveEntry.Name);
|
|
|
|
foreach ((string Name, bool IsDirectory) file in saveFileEntries.Where(e => !e.IsDirectory))
|
|
{
|
|
await DownloadFileAsync(
|
|
saveUrl + Uri.EscapeDataString(file.Name),
|
|
Path.Combine(localSaveDir, file.Name));
|
|
|
|
if (file.Name.StartsWith("bakedUnityAsset-", StringComparison.OrdinalIgnoreCase) &&
|
|
file.Name.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
try
|
|
{
|
|
BakedUnityAsset baked = ReadJson<BakedUnityAsset>(
|
|
Path.Combine(localSaveDir, file.Name));
|
|
if (!string.IsNullOrWhiteSpace(baked.Filename))
|
|
referencedBundleFilenames.Add(Path.GetFileName(baked.Filename));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT URL] Unreadable baked asset metadata {file.Name}: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (subRoomsFound == 0)
|
|
{
|
|
throw new InvalidDataException(
|
|
"No subroom folders with a subRoom.json were found under that URL.");
|
|
}
|
|
|
|
if (referencedBundleFilenames.Count > 0 &&
|
|
rootEntries.Any(entry => entry.IsDirectory &&
|
|
string.Equals(entry.Name, "AssetBundles", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
string bundlesUrl = normalizedRoot + "AssetBundles/";
|
|
string localBundlesDir = Path.Combine(stagingRoot, "AssetBundles");
|
|
foreach (string filename in referencedBundleFilenames)
|
|
{
|
|
try
|
|
{
|
|
await DownloadFileAsync(
|
|
bundlesUrl + Uri.EscapeDataString(filename),
|
|
Path.Combine(localBundlesDir, filename));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(
|
|
$"[ROOM IMPORT URL] Could not fetch asset bundle {filename}: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
return Import(stagingRoot, creatorAccountId, replaceExisting);
|
|
}
|
|
finally
|
|
{
|
|
try
|
|
{
|
|
if (Directory.Exists(stagingRoot))
|
|
Directory.Delete(stagingRoot, recursive: true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT URL] Could not clean up staging folder: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static async Task<List<(string Name, string Url)>> DiscoverRoomFoldersAsync(
|
|
string rootUrl,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(rootUrl) ||
|
|
!Uri.TryCreate(rootUrl, UriKind.Absolute, out Uri? rootUri) ||
|
|
(rootUri.Scheme != Uri.UriSchemeHttp && rootUri.Scheme != Uri.UriSchemeHttps))
|
|
{
|
|
throw new InvalidDataException("Enter a valid http:// or https:// URL to the rooms index folder.");
|
|
}
|
|
|
|
string normalizedRoot = rootUrl.TrimEnd('/') + "/";
|
|
List<(string Name, bool IsDirectory)> entries =
|
|
await ListRemoteDirectoryAsync(normalizedRoot, cancellationToken);
|
|
|
|
if (entries.Any(entry => !entry.IsDirectory &&
|
|
string.Equals(entry.Name, "room.json", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
string singleName = rootUri.Segments.Length > 0
|
|
? Uri.UnescapeDataString(rootUri.Segments[^1].Trim('/'))
|
|
: normalizedRoot;
|
|
return new List<(string Name, string Url)>
|
|
{
|
|
(string.IsNullOrWhiteSpace(singleName) ? normalizedRoot : singleName, normalizedRoot)
|
|
};
|
|
}
|
|
|
|
const int maxCandidates = 300;
|
|
var found = new List<(string Name, string Url)>();
|
|
foreach ((string Name, bool IsDirectory) entry in entries.Where(entry =>
|
|
entry.IsDirectory &&
|
|
!string.Equals(entry.Name, "AssetBundles", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
if (found.Count >= maxCandidates)
|
|
break;
|
|
|
|
string candidateUrl = normalizedRoot + Uri.EscapeDataString(entry.Name) + "/";
|
|
List<(string Name, bool IsDirectory)> candidateEntries;
|
|
try
|
|
{
|
|
candidateEntries = await ListRemoteDirectoryAsync(candidateUrl, cancellationToken);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[ROOM IMPORT URL DISCOVER] Skipping {candidateUrl}: {ex.Message}");
|
|
continue;
|
|
}
|
|
|
|
if (candidateEntries.Any(e => !e.IsDirectory &&
|
|
string.Equals(e.Name, "room.json", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
found.Add((entry.Name, candidateUrl));
|
|
}
|
|
}
|
|
|
|
if (found.Count == 0)
|
|
{
|
|
throw new InvalidDataException(
|
|
"No room folders (containing room.json) were found directly under that URL.");
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
private static async Task<List<(string Name, bool IsDirectory)>> ListRemoteDirectoryAsync(
|
|
string url,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
string html = await DownloadClient.GetStringAsync(url, cancellationToken);
|
|
var entries = new List<(string Name, bool IsDirectory)>();
|
|
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
foreach (Match match in Regex.Matches(html, "href\\s*=\\s*\"([^\"]+)\"", RegexOptions.IgnoreCase))
|
|
{
|
|
string href = System.Net.WebUtility.HtmlDecode(match.Groups[1].Value).Trim();
|
|
if (string.IsNullOrWhiteSpace(href) ||
|
|
href.StartsWith('#') ||
|
|
href.StartsWith('?') ||
|
|
href is "../" or ".." or "/" or "./")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (href.Contains("://"))
|
|
{
|
|
|
|
if (!Uri.TryCreate(href, UriKind.Absolute, out Uri? absolute) ||
|
|
!Uri.TryCreate(url, UriKind.Absolute, out Uri? baseUri) ||
|
|
!string.Equals(absolute.Host, baseUri.Host, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
bool isDirectory = href.EndsWith('/');
|
|
string trimmed = href.TrimEnd('/');
|
|
string rawName = trimmed.Contains('/') ? trimmed[(trimmed.LastIndexOf('/') + 1)..] : trimmed;
|
|
string name = Uri.UnescapeDataString(rawName);
|
|
|
|
if (string.IsNullOrWhiteSpace(name) || name is ".." or "." || name.Contains('\0'))
|
|
continue;
|
|
|
|
if (seen.Add(name))
|
|
entries.Add((name, isDirectory));
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private static ImportResult ImportUnityExport(
|
|
ExportRoom exportRoom,
|
|
long creatorAccountId,
|
|
bool replaceExisting)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(exportRoom.Name))
|
|
throw new InvalidDataException("Room metadata must contain a Name.");
|
|
|
|
var sourceSubRooms = (exportRoom.SubRooms ?? new List<ExportSubRoom>())
|
|
.Where(subRoom => !string.IsNullOrWhiteSpace(subRoom.UnitySceneId))
|
|
.ToList();
|
|
|
|
long assignedRoomId = RoomDB.GetNextRoomId();
|
|
string normalizedRoomName = exportRoom.Name.Trim().TrimStart('^');
|
|
Room? existingByName = RoomDB.Rooms.FindAll().FirstOrDefault(room =>
|
|
string.Equals(room.Name, normalizedRoomName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (sourceSubRooms.Count == 0 && !string.IsNullOrWhiteSpace(exportRoom.UnitySceneId))
|
|
{
|
|
sourceSubRooms.Add(new ExportSubRoom
|
|
{
|
|
RoomId = assignedRoomId,
|
|
SubRoomId = exportRoom.SubRoomId,
|
|
Name = "Home",
|
|
UnitySceneId = exportRoom.UnitySceneId,
|
|
MaxPlayers = exportRoom.MaxPlayers,
|
|
Accessibility = exportRoom.Accessibility
|
|
});
|
|
}
|
|
|
|
if (sourceSubRooms.Count == 0)
|
|
throw new InvalidDataException("No UnitySceneId was found in the room metadata.");
|
|
|
|
if (replaceExisting)
|
|
{
|
|
if (existingByName != null)
|
|
{
|
|
RoomDB.SubRoomDataSaves.DeleteMany(save => save.RoomId == existingByName.RoomId);
|
|
RoomDB.Rooms.Delete(existingByName.RoomId);
|
|
}
|
|
}
|
|
else if (existingByName != null)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"A room named \"{normalizedRoomName}\" already exists. Enable replaceExisting to overwrite it.");
|
|
}
|
|
|
|
long generatedSubRoomId = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
var importedSubRooms = new List<SubRooms>();
|
|
|
|
foreach ((ExportSubRoom source, int index) in sourceSubRooms.Select((value, index) => (value, index)))
|
|
{
|
|
long subRoomId = source.SubRoomId > 0 ? source.SubRoomId : generatedSubRoomId + index;
|
|
int accessibilityValue = Enum.IsDefined(typeof(RoomAccessibility), source.Accessibility)
|
|
? source.Accessibility
|
|
: (int)RoomAccessibility.Public;
|
|
|
|
importedSubRooms.Add(new SubRooms
|
|
{
|
|
SubRoomId = subRoomId,
|
|
RoomId = assignedRoomId,
|
|
Name = string.IsNullOrWhiteSpace(source.Name) ? $"Scene {index + 1}" : source.Name,
|
|
DataBlob = null,
|
|
SubRoomDataSaveId = 0,
|
|
SubRoomDataSave = null,
|
|
IsSandbox = source.IsSandbox,
|
|
MaxPlayers = source.MaxPlayers > 0
|
|
? Math.Clamp(source.MaxPlayers, 1, 100)
|
|
: Math.Clamp(exportRoom.MaxPlayers > 0 ? exportRoom.MaxPlayers : 6, 1, 100),
|
|
Accessibility = (RoomAccessibility)accessibilityValue,
|
|
UnitySceneId = source.UnitySceneId!.Trim(),
|
|
SavedByAccountId = creatorAccountId,
|
|
Permissions = new List<SubRoomPermission>()
|
|
});
|
|
}
|
|
|
|
SubRooms playableSubRoom = importedSubRooms.FirstOrDefault(subRoom =>
|
|
string.Equals(subRoom.Name, "Home", StringComparison.OrdinalIgnoreCase)) ?? importedSubRooms[0];
|
|
playableSubRoom.Name = "Home";
|
|
importedSubRooms.Remove(playableSubRoom);
|
|
importedSubRooms.Insert(0, playableSubRoom);
|
|
|
|
int roomAccessibility = Enum.IsDefined(typeof(RoomAccessibility), exportRoom.Accessibility)
|
|
? exportRoom.Accessibility
|
|
: (int)RoomAccessibility.Public;
|
|
|
|
var room = new Room
|
|
{
|
|
RoomId = assignedRoomId,
|
|
IsDorm = false,
|
|
MaxPlayerCalculationMode = 0,
|
|
MaxPlayers = Math.Clamp(
|
|
exportRoom.MaxPlayers > 0 ? exportRoom.MaxPlayers : playableSubRoom.MaxPlayers,
|
|
1,
|
|
100),
|
|
CloningAllowed = false,
|
|
DisableMicAutoMute = false,
|
|
DisableRoomComments = false,
|
|
EncryptVoiceChat = false,
|
|
ToxmodEnabled = true,
|
|
LoadScreenLocked = false,
|
|
PersistenceVersion = NormalizePersistenceVersion(
|
|
exportRoom.PersistenceVersion > 0 ? exportRoom.PersistenceVersion : 27),
|
|
AutoLocalizeRoom = false,
|
|
IsDeveloperOwned = true,
|
|
Name = exportRoom.Name.Trim().TrimStart('^'),
|
|
Description = string.IsNullOrWhiteSpace(exportRoom.Description)
|
|
? "Imported built-in Unity scene room."
|
|
: exportRoom.Description,
|
|
ImageName = exportRoom.ImageName ?? string.Empty,
|
|
WarningMask = 0,
|
|
CustomWarning = null,
|
|
CreatorAccountId = creatorAccountId,
|
|
State = RoomState.Active,
|
|
Accessibility = (RoomAccessibility)roomAccessibility,
|
|
SupportsLevelVoting = false,
|
|
IsRRO = true,
|
|
IsBaseRoom = true,
|
|
SupportsScreens = true,
|
|
SupportsWalkVR = true,
|
|
SupportsTeleportVR = true,
|
|
SupportsVRLow = true,
|
|
SupportsQuest2 = true,
|
|
SupportsMobile = true,
|
|
SupportsJuniors = true,
|
|
MinLevel = 0,
|
|
CreatedAt = DateTime.UtcNow,
|
|
Stats = new Stats(),
|
|
RankedEntityId = assignedRoomId.ToString(),
|
|
RankingContext = null,
|
|
SubRooms = importedSubRooms,
|
|
Roles = new List<Roles>
|
|
{
|
|
new()
|
|
{
|
|
AccountId = creatorAccountId,
|
|
Role = Role.Creator,
|
|
InvitedRole = Role.None
|
|
}
|
|
},
|
|
DataBlob = null,
|
|
UgcVersion = 1,
|
|
Tags = new List<Tags>
|
|
{
|
|
new() { Tag = "base", Type = TagType.Auto },
|
|
new() { Tag = "rro", Type = TagType.AGOnly }
|
|
},
|
|
PromoImages = new List<string>(),
|
|
PromoExternalContent = new List<PromoExternalContent>(),
|
|
LoadScreens = new List<LoadScreens>()
|
|
};
|
|
|
|
if (!RoomDB.Rooms.Upsert(room))
|
|
throw new InvalidOperationException("LiteDB failed to save the imported Unity-scene room.");
|
|
|
|
return new ImportResult(
|
|
room.RoomId,
|
|
importedSubRooms.Count,
|
|
0,
|
|
0,
|
|
0,
|
|
playableSubRoom.Name,
|
|
playableSubRoom.SubRoomId);
|
|
}
|
|
|
|
public sealed record RoomExportResult(
|
|
long RoomId,
|
|
string ExportRoot,
|
|
int SubRoomsExported,
|
|
int SavesExported,
|
|
bool ImageExported,
|
|
int BakedAssetsExported,
|
|
int AssetBundlesExported);
|
|
|
|
public static RoomExportResult ExportRoomToDirectory(
|
|
long roomId,
|
|
string outputRoot)
|
|
{
|
|
RoomDBClasses.Room room = RoomDB.GetRoom(roomId);
|
|
if (room == null || room.RoomId <= 0)
|
|
throw new FileNotFoundException($"Room {roomId} was not found.");
|
|
|
|
Directory.CreateDirectory(outputRoot);
|
|
|
|
string roomBlobSource = Path.Combine(Program.dataDir, "CDN", "room");
|
|
string assetBundleSourceRoot = Path.Combine(Program.dataDir, "CDN", "assetbundles");
|
|
string imageSourceRoot = Path.Combine(Program.dataDir, "Images");
|
|
string assetBundleDestination = Path.Combine(outputRoot, "AssetBundles");
|
|
|
|
var exportSubRooms = new List<ExportSubRoom>();
|
|
int savesExported = 0;
|
|
int bakedAssetsExported = 0;
|
|
var exportedBundleNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
foreach (SubRooms subRoom in room.SubRooms ?? new List<SubRooms>())
|
|
{
|
|
string subRoomDirectory = Path.Combine(outputRoot, subRoom.SubRoomId.ToString());
|
|
string savesDirectory = Path.Combine(subRoomDirectory, "Saves");
|
|
Directory.CreateDirectory(savesDirectory);
|
|
|
|
List<SubRoomDataSave> saves = RoomDB.SubRoomDataSaves
|
|
.Find(save => save.RoomId == roomId && save.SubRoomId == subRoom.SubRoomId)
|
|
.OrderBy(save => save.CreatedAt)
|
|
.ToList();
|
|
|
|
foreach (SubRoomDataSave save in saves)
|
|
{
|
|
string safeBlobName = Path.GetFileName(save.DataBlob ?? string.Empty);
|
|
string sourceBlobPath = Path.Combine(roomBlobSource, safeBlobName);
|
|
if (string.IsNullOrWhiteSpace(safeBlobName) || !File.Exists(sourceBlobPath))
|
|
{
|
|
Console.WriteLine(
|
|
$"[ROOM EXPORT] Missing blob for save {save.SubRoomDataSaveId}; skipped.");
|
|
continue;
|
|
}
|
|
|
|
string saveDirectoryName = save.SubRoomDataSaveId.ToString();
|
|
string saveDirectory = Path.Combine(savesDirectory, saveDirectoryName);
|
|
Directory.CreateDirectory(saveDirectory);
|
|
|
|
File.Copy(
|
|
sourceBlobPath,
|
|
Path.Combine(saveDirectory, safeBlobName),
|
|
overwrite: true);
|
|
|
|
var exportSave = new ExportSave
|
|
{
|
|
SubRoomDataSaveId = save.SubRoomDataSaveId,
|
|
SubRoomId = save.SubRoomId,
|
|
UnityAssetId = save.UnityAssetId,
|
|
DataBlob = safeBlobName,
|
|
DataBlobHash = save.DataBlobHash,
|
|
ReferencedUnityAssetIds = save.ReferencedUnityAssetIds,
|
|
PersistenceVersion = save.PersistenceVersion.GetValueOrDefault(),
|
|
OMVersion = save.OMVersion,
|
|
UgcSubVersion = save.UgcSubVersion,
|
|
SavedOnPlatform = save.SavedOnPlatform,
|
|
SavedOnDeviceClass = save.SavedOnDeviceClass,
|
|
Description = save.Description,
|
|
Tags = save.Tags,
|
|
ModerationState = save.ModerationState,
|
|
CreatedAt = save.CreatedAt
|
|
};
|
|
WriteJson(Path.Combine(saveDirectory, saveDirectoryName + ".json"), exportSave);
|
|
|
|
int bakedIndex = 0;
|
|
foreach (BakedUnityAsset bakedAsset in save.BakedUnityAssets ?? new List<BakedUnityAsset>())
|
|
{
|
|
string versionSuffix = string.IsNullOrWhiteSpace(bakedAsset.UnityVersion)
|
|
? string.Empty
|
|
: $"-Unity_{bakedAsset.UnityVersion.Replace('.', '_')}";
|
|
string bakedJsonName = $"bakedUnityAsset-{bakedIndex++}{versionSuffix}.json";
|
|
WriteJson(Path.Combine(saveDirectory, bakedJsonName), bakedAsset);
|
|
bakedAssetsExported++;
|
|
|
|
string bundleFileName = Path.GetFileName(bakedAsset.Filename ?? string.Empty);
|
|
if (string.IsNullOrWhiteSpace(bundleFileName))
|
|
continue;
|
|
|
|
string bundleSourcePath = Path.Combine(assetBundleSourceRoot, bundleFileName);
|
|
if (!File.Exists(bundleSourcePath))
|
|
continue;
|
|
|
|
if (exportedBundleNames.Add(bundleFileName))
|
|
{
|
|
Directory.CreateDirectory(assetBundleDestination);
|
|
File.Copy(
|
|
bundleSourcePath,
|
|
Path.Combine(assetBundleDestination, bundleFileName),
|
|
overwrite: true);
|
|
}
|
|
}
|
|
|
|
savesExported++;
|
|
}
|
|
|
|
var exportSubRoom = new ExportSubRoom
|
|
{
|
|
RoomId = roomId,
|
|
SubRoomId = subRoom.SubRoomId,
|
|
Name = subRoom.Name,
|
|
UnitySceneId = subRoom.UnitySceneId,
|
|
IsSandbox = subRoom.IsSandbox,
|
|
MaxPlayers = subRoom.MaxPlayers,
|
|
Accessibility = (int)subRoom.Accessibility,
|
|
CurrentSave = new ExportSave { SubRoomDataSaveId = subRoom.SubRoomDataSaveId }
|
|
};
|
|
WriteJson(Path.Combine(subRoomDirectory, "subRoom.json"), exportSubRoom);
|
|
exportSubRooms.Add(exportSubRoom);
|
|
}
|
|
|
|
if (savesExported == 0)
|
|
throw new InvalidDataException($"Room {roomId} has no save blobs on disk to export.");
|
|
|
|
bool imageExported = false;
|
|
if (!string.IsNullOrWhiteSpace(room.ImageName))
|
|
{
|
|
string imageSourcePath = Path.Combine(imageSourceRoot, room.ImageName);
|
|
if (File.Exists(imageSourcePath))
|
|
{
|
|
File.Copy(
|
|
imageSourcePath,
|
|
Path.Combine(outputRoot, Path.GetFileName(room.ImageName)),
|
|
overwrite: true);
|
|
imageExported = true;
|
|
}
|
|
}
|
|
|
|
var exportRoom = new ExportRoom
|
|
{
|
|
RoomId = room.RoomId,
|
|
Name = room.Name,
|
|
Description = room.Description,
|
|
ImageName = room.ImageName,
|
|
MaxPlayers = room.MaxPlayers,
|
|
Accessibility = (int)room.Accessibility,
|
|
PersistenceVersion = room.PersistenceVersion,
|
|
SubRoomId = room.SubRooms?.FirstOrDefault()?.SubRoomId ?? 0,
|
|
UnitySceneId = room.SubRooms?.FirstOrDefault()?.UnitySceneId,
|
|
SubRooms = exportSubRooms
|
|
};
|
|
WriteJson(Path.Combine(outputRoot, "room.json"), exportRoom);
|
|
|
|
return new RoomExportResult(
|
|
room.RoomId,
|
|
outputRoot,
|
|
exportSubRooms.Count,
|
|
savesExported,
|
|
imageExported,
|
|
bakedAssetsExported,
|
|
exportedBundleNames.Count);
|
|
}
|
|
|
|
private static void WriteJson<T>(string path, T value)
|
|
{
|
|
File.WriteAllText(
|
|
path,
|
|
JsonSerializer.Serialize(value, new JsonSerializerOptions
|
|
{
|
|
WriteIndented = true
|
|
}));
|
|
}
|
|
|
|
private static void MergeSubRoomMetadata(ExportSubRoom listed, ExportSubRoom source)
|
|
{
|
|
listed.Name = string.IsNullOrWhiteSpace(source.Name) ? listed.Name : source.Name;
|
|
listed.UnitySceneId = string.IsNullOrWhiteSpace(source.UnitySceneId)
|
|
? listed.UnitySceneId
|
|
: source.UnitySceneId;
|
|
listed.MaxPlayers = source.MaxPlayers > 0 ? source.MaxPlayers : listed.MaxPlayers;
|
|
listed.Accessibility = source.Accessibility;
|
|
listed.IsSandbox = source.IsSandbox;
|
|
listed.CurrentSave = source.CurrentSave ?? listed.CurrentSave;
|
|
}
|
|
|
|
private static bool CopyRoomImage(
|
|
string exportRoot,
|
|
string? requestedImageName,
|
|
string destinationRoot,
|
|
out string imageName)
|
|
{
|
|
string requestedFileName = Path.GetFileName(requestedImageName ?? string.Empty);
|
|
imageName = requestedFileName;
|
|
string? sourcePath = null;
|
|
|
|
if (!string.IsNullOrWhiteSpace(requestedFileName))
|
|
{
|
|
sourcePath = Directory.EnumerateFiles(exportRoot, "*", SearchOption.TopDirectoryOnly)
|
|
.FirstOrDefault(path => string.Equals(
|
|
Path.GetFileName(path),
|
|
requestedFileName,
|
|
StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
sourcePath ??= Directory.EnumerateFiles(exportRoot, "*", SearchOption.TopDirectoryOnly)
|
|
.FirstOrDefault(path => IsImageExtension(Path.GetExtension(path)));
|
|
|
|
if (sourcePath == null)
|
|
{
|
|
imageName = string.Empty;
|
|
return false;
|
|
}
|
|
|
|
imageName = Path.GetFileName(sourcePath);
|
|
string destinationPath = Path.Combine(destinationRoot, imageName);
|
|
return CopyIfDifferent(sourcePath, destinationPath) || File.Exists(destinationPath);
|
|
}
|
|
|
|
private static bool IsImageExtension(string extension) =>
|
|
extension.Equals(".png", StringComparison.OrdinalIgnoreCase) ||
|
|
extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) ||
|
|
extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase) ||
|
|
extension.Equals(".webp", StringComparison.OrdinalIgnoreCase) ||
|
|
extension.Equals(".gif", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static string? FindDirectory(string root, string name)
|
|
{
|
|
string direct = Path.Combine(root, name);
|
|
if (Directory.Exists(direct))
|
|
return direct;
|
|
|
|
return Directory.EnumerateDirectories(root, "*", SearchOption.TopDirectoryOnly)
|
|
.FirstOrDefault(path => string.Equals(
|
|
Path.GetFileName(path),
|
|
name,
|
|
StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
private static bool CopyIfDifferent(string sourcePath, string destinationPath)
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
|
|
if (File.Exists(destinationPath))
|
|
{
|
|
var sourceInfo = new FileInfo(sourcePath);
|
|
var destinationInfo = new FileInfo(destinationPath);
|
|
if (sourceInfo.Length == destinationInfo.Length &&
|
|
string.Equals(
|
|
ComputeSha256Base64(sourcePath),
|
|
ComputeSha256Base64(destinationPath),
|
|
StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
File.Copy(sourcePath, destinationPath, overwrite: true);
|
|
return true;
|
|
}
|
|
|
|
private static string? ParseUnityVersionFromMetadataName(string fileName)
|
|
{
|
|
|
|
const string marker = "Unity_";
|
|
int markerIndex = fileName.LastIndexOf(marker, StringComparison.OrdinalIgnoreCase);
|
|
if (markerIndex < 0)
|
|
return null;
|
|
|
|
int start = markerIndex + marker.Length;
|
|
int end = fileName.EndsWith(".json", StringComparison.OrdinalIgnoreCase)
|
|
? fileName.Length - 5
|
|
: fileName.Length;
|
|
if (start >= end)
|
|
return null;
|
|
|
|
return fileName[start..end].Replace('_', '.');
|
|
}
|
|
|
|
private static int NormalizePersistenceVersion(int sourceVersion)
|
|
{
|
|
if (sourceVersion <= 0)
|
|
return CompatiblePersistenceVersion;
|
|
|
|
return Math.Min(sourceVersion, CompatiblePersistenceVersion);
|
|
}
|
|
|
|
private static int NormalizeUgcSubVersion(int sourceVersion)
|
|
{
|
|
return CompatibleUgcSubVersion;
|
|
}
|
|
|
|
private static DateTime NormalizeCreatedAt(DateTime createdAt)
|
|
{
|
|
if (createdAt == default)
|
|
return DateTime.UtcNow;
|
|
return createdAt.Kind == DateTimeKind.Utc
|
|
? createdAt
|
|
: createdAt.ToUniversalTime();
|
|
}
|
|
|
|
private static bool TryGetProperty(
|
|
JsonElement element,
|
|
string propertyName,
|
|
out JsonElement value)
|
|
{
|
|
if (element.ValueKind == JsonValueKind.Object)
|
|
{
|
|
foreach (JsonProperty property in element.EnumerateObject())
|
|
{
|
|
if (property.Name.Equals(propertyName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
value = property.Value;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
value = default;
|
|
return false;
|
|
}
|
|
|
|
private static T ReadJson<T>(string path)
|
|
{
|
|
string json = File.ReadAllText(path, Encoding.UTF8);
|
|
return JsonSerializer.Deserialize<T>(json, JsonOptions)
|
|
?? throw new InvalidDataException($"Could not deserialize {path}.");
|
|
}
|
|
|
|
private static string ComputeSha256Base64(string path)
|
|
{
|
|
using FileStream stream = File.OpenRead(path);
|
|
return Convert.ToBase64String(SHA256.HashData(stream));
|
|
}
|
|
|
|
private sealed class ExportRoom
|
|
{
|
|
public long RoomId { get; set; }
|
|
public string Name { get; set; } = string.Empty;
|
|
public string? Description { get; set; }
|
|
public string? ImageName { get; set; }
|
|
public int MaxPlayers { get; set; }
|
|
public int Accessibility { get; set; }
|
|
public int PersistenceVersion { get; set; }
|
|
public long SubRoomId { get; set; }
|
|
public string? UnitySceneId { get; set; }
|
|
public List<ExportSubRoom>? SubRooms { get; set; }
|
|
}
|
|
|
|
private sealed class ExportSubRoom
|
|
{
|
|
public long RoomId { get; set; }
|
|
public long SubRoomId { get; set; }
|
|
public string Name { get; set; } = string.Empty;
|
|
public string? UnitySceneId { get; set; }
|
|
public ExportSave? CurrentSave { get; set; }
|
|
public bool IsSandbox { get; set; }
|
|
public int MaxPlayers { get; set; }
|
|
public int Accessibility { get; set; }
|
|
}
|
|
|
|
private sealed class ExportSave
|
|
{
|
|
public long SubRoomDataSaveId { get; set; }
|
|
public long SubRoomId { get; set; }
|
|
public string? UnityAssetId { get; set; }
|
|
public string DataBlob { get; set; } = string.Empty;
|
|
public string? DataBlobHash { get; set; }
|
|
public List<string>? ReferencedUnityAssetIds { get; set; }
|
|
public int PersistenceVersion { get; set; }
|
|
public int OMVersion { get; set; }
|
|
public int UgcSubVersion { get; set; }
|
|
public int? SavedOnPlatform { get; set; }
|
|
public int? SavedOnDeviceClass { get; set; }
|
|
public string? Description { get; set; }
|
|
public List<string>? Tags { get; set; }
|
|
public int ModerationState { get; set; }
|
|
public DateTime CreatedAt { get; set; }
|
|
}
|
|
}
|