LCOV - code coverage report
Current view: top level - save - serde.go Coverage Total Hit
Test: coverage.lcov Lines: 97.1 % 104 101
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package save
       2              : 
       3              : import (
       4              :         "crypto/sha256"
       5              :         "encoding/hex"
       6              :         "encoding/json"
       7              :         "fmt"
       8              :         "time"
       9              : 
      10              :         gc "github.com/kijimaD/ruins/internal/components"
      11              :         "github.com/kijimaD/ruins/internal/gamelog"
      12              :         w "github.com/kijimaD/ruins/internal/world"
      13              :         arkserde "github.com/mlange-42/ark-serde"
      14              :         "github.com/mlange-42/ark/ecs"
      15              : )
      16              : 
      17              : // saveEnvelope はセーブファイルの外枠。ark-serde のワールドJSONをメタ情報で包む
      18              : type saveEnvelope struct {
      19              :         Version   string        `json:"version"`
      20              :         Timestamp time.Time     `json:"timestamp"`
      21              :         PlayTime  time.Duration `json:"playTime"`
      22              :         // Checksum はキーレスSHA-256による破損検知用の値。改ざん検知(攻撃者が
      23              :         // world改変後にchecksumを再計算できる)は目的としない
      24              :         Checksum   string          `json:"checksum"`
      25              :         PlayerName string          `json:"playerName"`
      26              :         World      json.RawMessage `json:"world"`
      27              : }
      28              : 
      29              : // skipComponents はserde除外対象を返す。
      30              : // serde非互換(struct-keyed map / interface / mutex)と、毎フレーム・毎ターン
      31              : // 再生成される一時状態のみを除外し、地形・敵・アイテムを含む残りは丸ごと保存する。
      32              : // フラグ駆動で再計算する派生はこの一時状態に当たらないので、ダーティフラグでも保存する。
      33              : func skipComponents() []ecs.Comp {
      34            1 :         return []ecs.Comp{
      35            1 :                 ecs.C[gc.SpatialIndex](),       // struct-keyed map。ロード時に再構築
      36            1 :                 ecs.C[gc.VisionState](),        // struct-keyed map。視界更新で再構築
      37            1 :                 ecs.C[gc.PlayTime](),           // セッション状態。永続は envelope。ロードで seed
      38            1 :                 ecs.C[gc.GameLog](),            // sync.Mutex を含むため不可。毎ロード初期化
      39            1 :                 ecs.C[gc.VisualEffects](),      // interfaceスライス・毎フレーム再生成
      40            1 :                 ecs.C[gc.Position](),           // GridElementから毎フレーム算出
      41            1 :                 ecs.C[gc.StateChangeRequest](), // イベント・毎ターン消費
      42            1 :                 ecs.C[gc.Dead](),               // 一時・毎ターン掃除
      43            1 :                 ecs.C[gc.Activity](),           // 実行中アクティビティ・毎ターン変動
      44            1 :                 ecs.C[gc.LastActivity](),       // ターン進行で消費
      45            1 :                 ecs.C[gc.UserSettings](),       // config 由来のランタイムミラー。ロード時に config から再構築
      46            1 :         }
      47              : }
      48              : 
      49              : // serializeWorld はワールドをark-serdeでJSON化する。一時状態とリソースは除外する
      50              : func serializeWorld(world w.World) ([]byte, error) {
      51            1 :         return arkserde.Serialize(world.ECS,
      52            1 :                 arkserde.Opts.SkipComponents(skipComponents()...),
      53            1 :                 arkserde.Opts.SkipAllResources(),
      54            1 :         )
      55            1 : }
      56              : 
      57              : // deserializeWorld はJSONからワールドを復元する。呼び出し前にworldはReset済みであること。
      58              : //
      59              : // セーブファイルは破損しうる信頼境界であり、arkserde/ark は壊れた入力で panic することがある。
      60              : // panic を error に変換してゲームのクラッシュを防ぐ。ロード失敗は呼び出し側がエラー表示で扱う。
      61              : func deserializeWorld(world w.World, worldJSON []byte) (err error) {
      62            1 :         defer func() {
      63            1 :                 if r := recover(); r != nil {
      64            1 :                         err = fmt.Errorf("failed to restore save data; data may be corrupted: %v", r)
      65            1 :                 }
      66              :         }()
      67            1 :         return arkserde.Deserialize(worldJSON, world.ECS,
      68            1 :                 arkserde.Opts.SkipComponents(skipComponents()...),
      69            1 :                 arkserde.Opts.SkipAllResources(),
      70            1 :         )
      71              : }
      72              : 
      73              : // reestablishSingleton は復元後のシングルトンエンティティを再確立する。
      74              : // スキップした一時コンポーネント(GameLog/SpatialIndex)を再付与し、
      75              : // json:"-"で除外された視界マップを初期化し、Resourcesの参照を張り直す。
      76              : // playTime は envelope から読んだ累積で、PlayTime の計測をこの値から始める。
      77              : func reestablishSingleton(world w.World, playTime time.Duration) error {
      78              :         // Dungeonを持つ最初のエンティティをシングルトンとする。Dungeon はシングルトン専用の
      79              :         // 保存対象コンポーネントで、復元後も残る。途中returnはワールドをロックしたまま残すため、
      80              :         // クエリは最後まで反復する
      81            1 :         var singleton ecs.Entity
      82            1 :         found := false
      83            1 :         q := ecs.NewFilter1[gc.Dungeon](world.ECS).Query()
      84            1 :         for q.Next() {
      85            1 :                 if !found {
      86            1 :                         singleton = q.Entity()
      87            1 :                         found = true
      88            1 :                 }
      89              :         }
      90            1 :         if !found {
      91            1 :                 return errNoSingleton
      92            1 :         }
      93            1 :         world.Resources.SingletonEntity = singleton
      94            1 : 
      95            1 :         world.Components.GameLog.Add(singleton, &gc.GameLog{
      96            1 :                 Store: gamelog.NewSafeSlice(gamelog.GameLogMaxSize),
      97            1 :         })
      98            1 :         world.Components.SpatialIndex.Add(singleton, gc.NewSpatialIndex())
      99            1 :         // 視界計算の一時状態は serde 除外なのでロード後に再構築する
     100            1 :         world.Components.VisionState.Add(singleton, gc.NewVisionState())
     101            1 :         // プレイ実時間も serde 除外なので付け直し、envelope の値で計測を始める
     102            1 :         pt := &gc.PlayTime{}
     103            1 :         pt.Start(playTime, time.Now())
     104            1 :         world.Components.PlayTime.Add(singleton, pt)
     105            1 :         // グローバル設定は serde 除外なので config から再構築する
     106            1 :         world.Components.UserSettings.Add(singleton, gc.NewUserSettings(world.Resources.Config.User.Language))
     107            1 : 
     108              :         // 展開状態は Deployed と貨物がそのまま保存され復元される。レーザー壁は描画時に Deployed から
     109              :         // 毎フレーム作るだけでエンティティを持たないので、保存も掃除も要らない。
     110              : 
     111              :         // json:"-"で除外された各ステージの探索履歴を初期化する。入場時リセット方針なので空でよい。
     112              :         // ロック中の反復では構造変更しないため、対象を集めてから初期化する
     113            1 :         var metas []ecs.Entity
     114            1 :         mq := ecs.NewFilter1[gc.StageField](world.ECS).Query()
     115            1 :         for mq.Next() {
     116            1 :                 metas = append(metas, mq.Entity())
     117            1 :         }
     118            1 :         for _, e := range metas {
     119            1 :                 field := world.Components.StageField.Get(e)
     120            1 :                 if field.ExploredTiles == nil {
     121            1 :                         field.ExploredTiles = make(map[gc.GridElement]bool)
     122            1 :                 }
     123              :         }
     124              : 
     125            1 :         return nil
     126              : }
     127              : 
     128              : // validateStages は復元したステージ関連の値の整合を検査する。
     129              : // セーブファイルは信頼境界であり、コンストラクタを通らない不正な StageKey が
     130              : // 紛れうる。StageKey を内包する全コンポーネント、Dungeon.CurrentStage・StageBound.Key・
     131              : // PortalConnection.Stage を Validate で弾く。ロックを避けるため先にキーを集め、反復を終えてから検証する
     132              : func validateStages(world w.World) error {
     133            1 :         var keys []gc.StageKey
     134            1 :         dq := ecs.NewFilter1[gc.Dungeon](world.ECS).Query()
     135            1 :         for dq.Next() {
     136            1 :                 keys = append(keys, world.Components.Dungeon.Get(dq.Entity()).CurrentStage)
     137            1 :         }
     138            1 :         mq := ecs.NewFilter1[gc.StageBound](world.ECS).Query()
     139            1 :         for mq.Next() {
     140            1 :                 keys = append(keys, world.Components.StageBound.Get(mq.Entity()).Key)
     141            1 :         }
     142            1 :         pq := ecs.NewFilter1[gc.PortalConnection](world.ECS).Query()
     143            1 :         for pq.Next() {
     144            0 :                 keys = append(keys, world.Components.PortalConnection.Get(pq.Entity()).Stage)
     145            0 :         }
     146            1 :         for _, k := range keys {
     147            1 :                 if err := k.Validate(); err != nil {
     148            1 :                         return fmt.Errorf("%w: %w", errInvalidStageKey, err)
     149            1 :                 }
     150              :         }
     151            1 :         return nil
     152              : }
     153              : 
     154              : // extractPlayerName はワールドからプレイヤー名を取得する。存在しなければ空文字を返す。
     155              : // クエリを途中でreturnするとワールドがロックされたままになるため、必ず最後まで反復する
     156              : func extractPlayerName(world w.World) string {
     157            1 :         name := ""
     158            1 :         q := ecs.NewFilter1[gc.Player](world.ECS).Query()
     159            1 :         for q.Next() {
     160            1 :                 entity := q.Entity()
     161            1 :                 if name == "" && world.Components.Name.Has(entity) {
     162            1 :                         n := world.Components.Name.Get(entity)
     163            1 :                         name = n.Custom
     164            1 :                         if name == "" {
     165            1 :                                 name = string(n.Name)
     166            1 :                         }
     167              :                 }
     168              :         }
     169            1 :         return name
     170              : }
     171              : 
     172              : // checksumOf は破損検知用にチェックサムを除いたenvelopeのSHA-256を計算する。
     173              : // json.Marshal は json.RawMessage を compact するため、保存ファイルが
     174              : // MarshalIndent で整形されていても検証時に同一バイト列へ正規化され、値が一致する。
     175              : // envelopeは全てJSON互換型のためMarshalは失敗しないが、万一失敗した場合はpanicする
     176              : func checksumOf(env *saveEnvelope) string {
     177            1 :         target := saveEnvelope{
     178            1 :                 Version:    env.Version,
     179            1 :                 Timestamp:  env.Timestamp,
     180            1 :                 PlayTime:   env.PlayTime,
     181            1 :                 PlayerName: env.PlayerName,
     182            1 :                 World:      env.World,
     183            1 :         }
     184            1 :         jsonBytes, err := json.Marshal(target)
     185            1 :         if err != nil {
     186            0 :                 panic(fmt.Sprintf("failed to marshal for checksum: %v", err))
     187              :         }
     188            1 :         hash := sha256.Sum256(jsonBytes)
     189            1 :         return hex.EncodeToString(hash[:])
     190              : }
        

Generated by: LCOV version 2.0-1