EVERYTHING

This commit is contained in:
niko
2026-06-01 17:19:55 +02:00
parent d063b81359
commit b62bac090b
1081 changed files with 1716544 additions and 0 deletions
@@ -0,0 +1,263 @@
using System;
using System.IO;
using BlockSpace.Account;
using UnityEngine;
namespace BlockSpace.Voxels
{
public static class AvatarVoxelStorage
{
public const string PlayerPrefsKey = "BlockSpace.Avatar.Payload";
private const string AvatarPayloadFileName = "avatar_payload.json";
private static string GetAvatarPayloadPath()
{
string userFolderId = BlockSpaceAccountPrefs.GetUserFolderId();
return Path.Combine(Application.persistentDataPath, "BlockSpace", "Users", userFolderId, "avatar_payload.json");
}
private static string GetAvatarPayloadPathForUser(string userId)
{
return Path.Combine(Application.persistentDataPath, "BlockSpace", "Users", userId, "avatar_payload.json");
}
private static void TryMigrateLocalAvatarToLinked()
{
if (!BlockSpaceAccountPrefs.IsLinked)
{
return;
}
string linkedPlayerId = BlockSpaceAccountPrefs.GetLinkedPlayerId();
if (string.IsNullOrEmpty(linkedPlayerId))
{
return;
}
string avatarPayloadPathForUser = GetAvatarPayloadPathForUser(linkedPlayerId);
if (File.Exists(avatarPayloadPathForUser))
{
return;
}
string orCreateLocalUserId = BlockSpaceAccountPrefs.GetOrCreateLocalUserId();
if (string.IsNullOrEmpty(orCreateLocalUserId))
{
return;
}
string avatarPayloadPathForUser2 = GetAvatarPayloadPathForUser(orCreateLocalUserId);
if (!File.Exists(avatarPayloadPathForUser2))
{
return;
}
try
{
string directoryName = Path.GetDirectoryName(avatarPayloadPathForUser);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(directoryName);
}
File.Copy(avatarPayloadPathForUser2, avatarPayloadPathForUser, overwrite: true);
}
catch
{
}
}
public static AvatarVoxelPayload CreateEmptyPayload()
{
return new AvatarVoxelPayload();
}
public static AvatarVoxelPayload CapturePayload(VoxelGroup headBodyGroup, VoxelGroup leftGroup, VoxelGroup rightGroup)
{
return new AvatarVoxelPayload
{
headBody = CaptureGroup(headBodyGroup),
left = CaptureGroup(leftGroup),
right = CaptureGroup(rightGroup)
};
}
public static AvatarVoxelGroupData CaptureGroup(VoxelGroup group)
{
if (group == null)
{
return new AvatarVoxelGroupData();
}
return new AvatarVoxelGroupData
{
positionX = group.position.x,
positionY = group.position.y,
positionZ = group.position.z,
packedRotation = group.packedRotation,
sizeX = group.size.x,
sizeY = group.size.y,
sizeZ = group.size.z,
voxelsBase64 = ((group.voxels != null && group.voxels.Length != 0) ? Convert.ToBase64String(group.voxels) : string.Empty)
};
}
public static void ApplyPayload(AvatarVoxelPayload payload, VoxelGroup headBodyGroup, VoxelGroup leftGroup, VoxelGroup rightGroup, VoxelGroupManager manager, bool useLocalGridTransform)
{
AvatarVoxelPayload avatarVoxelPayload = payload ?? CreateEmptyPayload();
ApplyGroupData(headBodyGroup, avatarVoxelPayload.headBody, manager, useLocalGridTransform);
ApplyGroupData(leftGroup, avatarVoxelPayload.left, manager, useLocalGridTransform);
ApplyGroupData(rightGroup, avatarVoxelPayload.right, manager, useLocalGridTransform);
}
public static void ApplyGroupData(VoxelGroup group, AvatarVoxelGroupData data, VoxelGroupManager manager, bool useLocalGridTransform)
{
if (!(group == null) && !(manager == null))
{
AvatarVoxelGroupData avatarVoxelGroupData = data ?? new AvatarVoxelGroupData();
Vector3Int vector3Int = new Vector3Int(Mathf.Max(0, avatarVoxelGroupData.sizeX), Mathf.Max(0, avatarVoxelGroupData.sizeY), Mathf.Max(0, avatarVoxelGroupData.sizeZ));
byte[] array = DecodeVoxelBytes(avatarVoxelGroupData, vector3Int);
int num = ((vector3Int.x > 0 && vector3Int.y > 0 && vector3Int.z > 0) ? (vector3Int.x * vector3Int.y * vector3Int.z) : 0);
if (num > 0 && array.Length != num)
{
vector3Int = Vector3Int.zero;
array = new byte[0];
}
group.SetUseLocalGridTransform(useLocalGridTransform);
group.SetColliderGeneration(enabled: false);
group.SetOwner(manager);
group.OverwriteData(new Vector3Int(avatarVoxelGroupData.positionX, avatarVoxelGroupData.positionY, avatarVoxelGroupData.positionZ), (byte)Mathf.Clamp(avatarVoxelGroupData.packedRotation, 0, 255), vector3Int, array, queueRebuild: false);
group.SetGreedyRenderMeshing(enabled: true);
group.RebuildMesh();
group.RebuildCollider();
DisableCollider(group);
}
}
public static void SaveLocal(AvatarVoxelPayload payload)
{
try
{
string avatarPayloadPath = GetAvatarPayloadPath();
string directoryName = Path.GetDirectoryName(avatarPayloadPath);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(directoryName);
}
File.WriteAllText(avatarPayloadPath, Serialize(payload));
if (PlayerPrefs.HasKey("BlockSpace.Avatar.Payload"))
{
PlayerPrefs.DeleteKey("BlockSpace.Avatar.Payload");
PlayerPrefs.Save();
}
}
catch (Exception ex)
{
Debug.LogWarning("Failed to save avatar payload to disk, falling back to PlayerPrefs: " + ex.Message);
PlayerPrefs.SetString("BlockSpace.Avatar.Payload", Serialize(payload));
PlayerPrefs.Save();
}
}
public static AvatarVoxelPayload LoadLocalOrDefault()
{
if (!TryLoadLocal(out var payload))
{
return CreateEmptyPayload();
}
return payload;
}
public static bool TryLoadLocal(out AvatarVoxelPayload payload)
{
payload = CreateEmptyPayload();
try
{
TryMigrateLocalAvatarToLinked();
string avatarPayloadPath = GetAvatarPayloadPath();
if (File.Exists(avatarPayloadPath))
{
return TryDeserialize(File.ReadAllText(avatarPayloadPath), out payload);
}
}
catch (Exception ex)
{
Debug.LogWarning("Failed to load avatar payload from disk: " + ex.Message);
}
if (!PlayerPrefs.HasKey("BlockSpace.Avatar.Payload"))
{
return false;
}
bool num = TryDeserialize(PlayerPrefs.GetString("BlockSpace.Avatar.Payload", string.Empty), out payload);
if (num)
{
SaveLocal(payload);
}
return num;
}
public static string Serialize(AvatarVoxelPayload payload)
{
return JsonUtility.ToJson(payload ?? CreateEmptyPayload());
}
public static bool TryDeserialize(string json, out AvatarVoxelPayload payload)
{
payload = CreateEmptyPayload();
if (string.IsNullOrWhiteSpace(json))
{
return false;
}
try
{
AvatarVoxelPayload avatarVoxelPayload = JsonUtility.FromJson<AvatarVoxelPayload>(json);
if (avatarVoxelPayload == null)
{
return false;
}
if (avatarVoxelPayload.headBody == null)
{
avatarVoxelPayload.headBody = new AvatarVoxelGroupData();
}
if (avatarVoxelPayload.left == null)
{
avatarVoxelPayload.left = new AvatarVoxelGroupData();
}
if (avatarVoxelPayload.right == null)
{
avatarVoxelPayload.right = new AvatarVoxelGroupData();
}
payload = avatarVoxelPayload;
return true;
}
catch (Exception ex)
{
Debug.LogWarning("Failed to deserialize avatar payload: " + ex.Message);
return false;
}
}
private static byte[] DecodeVoxelBytes(AvatarVoxelGroupData data, Vector3Int size)
{
int num = ((size.x > 0 && size.y > 0 && size.z > 0) ? (size.x * size.y * size.z) : 0);
if (num <= 0 || string.IsNullOrEmpty(data.voxelsBase64))
{
return new byte[0];
}
try
{
byte[] array = Convert.FromBase64String(data.voxelsBase64);
if (array.Length == num)
{
return array;
}
}
catch (FormatException)
{
}
return new byte[0];
}
private static void DisableCollider(VoxelGroup group)
{
if (!(group.meshCollider == null))
{
group.meshCollider.enabled = false;
}
}
}
}