88 lines
4.0 KiB
C#
88 lines
4.0 KiB
C#
using System;
|
|
|
|
namespace ProjectM.Simulation
|
|
{
|
|
/// <summary>One serialized ledger row (item id + count). An array FIELD of <see cref="SaveData"/>.</summary>
|
|
[Serializable]
|
|
public struct LedgerRow
|
|
{
|
|
public int ItemId;
|
|
public int Count;
|
|
}
|
|
|
|
/// <summary>One persisted per-class PERMANENT meta-upgrade tier (v6). ClassId = the normalized CharacterId
|
|
/// (Warrior=2/Ranger=3); UpgradeId = the append-only meta-catalog key (unknown ids round-trip preserved and are
|
|
/// skipped live); Tier clamps to the catalog's MaxTier at seed/shop/spend, never at rest.</summary>
|
|
[Serializable]
|
|
public struct MetaUpgradeSave
|
|
{
|
|
public byte ClassId;
|
|
public byte UpgradeId;
|
|
public byte Tier;
|
|
}
|
|
|
|
/// <summary>
|
|
/// One serialized player-built structure (M7). Flat scalars (JsonUtility has no int2). The production
|
|
/// cooldown is stored as REMAINING ticks (epoch-independent) so it survives the server-tick origin reset on a
|
|
/// fresh session; the in-flight conveyor item (if any) rides here, while variable-length machine I/O buffers
|
|
/// live in the flat <see cref="SaveData.StructureIo"/> table keyed by index.
|
|
/// </summary>
|
|
[Serializable]
|
|
public struct StructureSave
|
|
{
|
|
public byte Type;
|
|
public int CellX;
|
|
public int CellZ;
|
|
public byte Direction; // conveyor facing (0 for non-conveyors)
|
|
public uint RemainingTicks; // production/cooldown ticks left at save time
|
|
public byte ConveyorResId; // in-flight conveyor item resource (0 = none)
|
|
public int ConveyorCount;
|
|
public float HP; // EB-1: hit points at save time (0 from a pre-v3 save -> restored to baked Max)
|
|
}
|
|
|
|
/// <summary>
|
|
/// One serialized machine I/O buffer row, joined to <see cref="SaveData.Structures"/> by
|
|
/// <see cref="StructureIndex"/>. A flat top-level array (JsonUtility can't nest arrays-of-arrays); Slot 0 =
|
|
/// MachineInput, Slot 1 = MachineOutput.
|
|
/// </summary>
|
|
[Serializable]
|
|
public struct StructureIoRow
|
|
{
|
|
public int StructureIndex;
|
|
public byte Slot;
|
|
public byte ResourceId;
|
|
public int Count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versioned, host-authoritative save slice (the FOUNDATION): the long-arc goal charge/target + the shared
|
|
/// resource ledger. JsonUtility-friendly — a class with flat fields and an array FIELD (never a root array).
|
|
/// The schema is intentionally ADDITIVE: future fields (placed structures, threat, storage) append without
|
|
/// breaking old saves, gated by <see cref="Version"/> migration.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class SaveData
|
|
{
|
|
public const int CurrentVersion = 6; // v6: permanent META (per-class upgrade tiers + run counters); v5 added RunOutcome; v4 added CoreCurrent
|
|
|
|
/// <summary>Oldest save schema the loader accepts (additive); a v2 save loads with structures at full HP.</summary>
|
|
public const int MinLoadableVersion = 2;
|
|
|
|
public int Version = CurrentVersion;
|
|
public int GoalCharge;
|
|
public int GoalTarget;
|
|
public int CoreCurrent; // END-1: Engine Core integrity at save time (0 from a pre-v4 save -> restored to baked Max)
|
|
public int RunOutcome; // END-2: 0=InProgress (also any pre-v5 save) / 1=Victory / 2=Loss -> a finished run loads finished
|
|
|
|
// v6 — permanent meta-progression (0/empty-defaults on any v<=5 save):
|
|
public int RunsCompleted; // boss-cleared runs (the HUD counter + the HostSalt fold at restore)
|
|
public int MaxDepthReached; // deepest room actually CLEARED across all runs (honest depth, never planned)
|
|
public MetaUpgradeSave[] MetaUpgrades = Array.Empty<MetaUpgradeSave>(); // sparse per-class tiers
|
|
|
|
public LedgerRow[] Ledger = Array.Empty<LedgerRow>();
|
|
public StructureSave[] Structures = Array.Empty<StructureSave>();
|
|
public StructureIoRow[] StructureIo = Array.Empty<StructureIoRow>();
|
|
public long SavedAtMs;
|
|
}
|
|
}
|