805 lines
23 KiB
C#
805 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
public sealed class StoreOwnershipLedger : MonoBehaviour
|
|
{
|
|
private const string RuntimeStoreItemResourcesPath = "so/storeSO";
|
|
|
|
public static StoreOwnershipLedger Instance { get; private set; }
|
|
|
|
public event Action<int> OnOwnershipChanged;
|
|
|
|
private readonly Dictionary<int, StoreOwnershipEntry> entriesByItemId = new Dictionary<int, StoreOwnershipEntry>();
|
|
private readonly List<storeItemSO> cachedStoreItems = new List<storeItemSO>();
|
|
private bool initialized;
|
|
private bool loadedFromSave;
|
|
private bool hasAnyRecoverableLocalState;
|
|
private int lastSaveFrame = -1;
|
|
|
|
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
|
|
private static void Bootstrap()
|
|
{
|
|
EnsureInstance();
|
|
}
|
|
|
|
public static StoreOwnershipLedger EnsureInstance()
|
|
{
|
|
if (Instance != null)
|
|
{
|
|
return Instance;
|
|
}
|
|
|
|
var host = new GameObject("__runtime_ownership_bridge");
|
|
host.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector;
|
|
DontDestroyOnLoad(host);
|
|
Instance = host.AddComponent<StoreOwnershipLedger>();
|
|
return Instance;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
|
|
Instance = this;
|
|
DontDestroyOnLoad(gameObject);
|
|
InitializeIfNeeded();
|
|
}
|
|
|
|
private void OnApplicationPause(bool pauseStatus)
|
|
{
|
|
if (pauseStatus)
|
|
{
|
|
SaveNow();
|
|
}
|
|
}
|
|
|
|
private void OnApplicationQuit()
|
|
{
|
|
SaveNow();
|
|
}
|
|
|
|
public void InitializeIfNeeded()
|
|
{
|
|
if (initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
initialized = true;
|
|
StoreOwnershipPayload payload;
|
|
loadedFromSave = StoreOwnershipStorage.TryLoad(out payload);
|
|
hasAnyRecoverableLocalState = loadedFromSave || StoreOwnershipStorage.HasAnyRecoverableState();
|
|
RebuildFromPayload(payload);
|
|
LoadStoreItems();
|
|
|
|
bool recoveredFromMirrors = false;
|
|
if (!loadedFromSave && !hasAnyRecoverableLocalState)
|
|
{
|
|
recoveredFromMirrors = SeedFromCurrentMirrorFlags();
|
|
}
|
|
|
|
if (loadedFromSave || recoveredFromMirrors)
|
|
{
|
|
SyncAllMirrorFlags();
|
|
SaveNow();
|
|
}
|
|
}
|
|
|
|
public void ForceSyncMirrorFlags()
|
|
{
|
|
InitializeIfNeeded();
|
|
LoadStoreItems();
|
|
SyncAllMirrorFlags();
|
|
}
|
|
|
|
public bool IsOwned(storeItemSO itemSO)
|
|
{
|
|
InitializeIfNeeded();
|
|
if (itemSO == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
StoreOwnershipEntry entry;
|
|
entriesByItemId.TryGetValue(itemSO.itemID, out entry);
|
|
|
|
switch (itemSO.itemType)
|
|
{
|
|
case storeItemSO.ItemType.character:
|
|
return (entry != null && entry.owned) || (itemSO.associatedAllyHero != null && itemSO.associatedAllyHero.isUnlocked);
|
|
case storeItemSO.ItemType.song:
|
|
return (entry != null && entry.owned) || (itemSO.associatedSong != null && itemSO.associatedSong.isUnlocked);
|
|
case storeItemSO.ItemType.storyPassage:
|
|
return IsStoryGrantOwned(itemSO, entry);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryGrantOwnership(storeItemSO itemSO, out string failureMessage)
|
|
{
|
|
InitializeIfNeeded();
|
|
failureMessage = string.Empty;
|
|
|
|
if (!ValidateGrantTarget(itemSO, out failureMessage))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var entry = GetOrCreateEntry(itemSO.itemID);
|
|
switch (itemSO.itemType)
|
|
{
|
|
case storeItemSO.ItemType.character:
|
|
case storeItemSO.ItemType.song:
|
|
entry.owned = true;
|
|
break;
|
|
|
|
case storeItemSO.ItemType.storyPassage:
|
|
GrantStoryOwnership(itemSO, entry);
|
|
break;
|
|
|
|
default:
|
|
failureMessage = LocalizationService.Get("store.error.grant_logic_missing", "当前未配置发放逻辑");
|
|
return false;
|
|
}
|
|
|
|
ApplyEntryToItem(itemSO, entry);
|
|
GlobalAchievementService.EnsureInstance().RefreshDerivedMetrics();
|
|
SaveNow();
|
|
NotifyOwnershipChanged(itemSO.itemID);
|
|
return true;
|
|
}
|
|
|
|
public bool TryRevokeOwnership(storeItemSO itemSO, out string failureMessage)
|
|
{
|
|
InitializeIfNeeded();
|
|
failureMessage = string.Empty;
|
|
|
|
if (itemSO == null)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.item_data_missing", "商品数据丢失");
|
|
return false;
|
|
}
|
|
|
|
StoreOwnershipEntry entry;
|
|
entriesByItemId.TryGetValue(itemSO.itemID, out entry);
|
|
if (entry == null && !IsOwned(itemSO))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (entry != null)
|
|
{
|
|
entry.owned = false;
|
|
if (entry.unlockedStorySonIds != null)
|
|
{
|
|
entry.unlockedStorySonIds.Clear();
|
|
}
|
|
|
|
if (!entry.owned && (entry.unlockedStorySonIds == null || entry.unlockedStorySonIds.Count == 0))
|
|
{
|
|
entriesByItemId.Remove(itemSO.itemID);
|
|
}
|
|
}
|
|
|
|
SyncAllMirrorFlags();
|
|
GlobalAchievementService.EnsureInstance().RefreshDerivedMetrics();
|
|
SaveNow();
|
|
NotifyOwnershipChanged(itemSO.itemID);
|
|
return true;
|
|
}
|
|
|
|
public bool TryGrantOwnershipPreview(storeItemSO itemSO, out string failureMessage)
|
|
{
|
|
InitializeIfNeeded();
|
|
return ValidateGrantTarget(itemSO, out failureMessage);
|
|
}
|
|
|
|
public void SaveNow()
|
|
{
|
|
if (!initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!loadedFromSave && hasAnyRecoverableLocalState)
|
|
{
|
|
Debug.LogWarning("[StoreOwnershipLedger] Recoverable save state exists but could not be loaded; skip saving to avoid overwriting older store ownership data.");
|
|
return;
|
|
}
|
|
|
|
if (Application.isPlaying && lastSaveFrame == Time.frameCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lastSaveFrame = Application.isPlaying ? Time.frameCount : -1;
|
|
StoreOwnershipStorage.TrySave(CreatePayload());
|
|
}
|
|
|
|
public void ClearPersistentState()
|
|
{
|
|
InitializeIfNeeded();
|
|
entriesByItemId.Clear();
|
|
SyncAllMirrorFlags();
|
|
StoreOwnershipStorage.TrySave(CreatePayload());
|
|
}
|
|
|
|
private void RebuildFromPayload(StoreOwnershipPayload payload)
|
|
{
|
|
entriesByItemId.Clear();
|
|
if (payload == null || payload.entries == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < payload.entries.Count; i++)
|
|
{
|
|
var entry = payload.entries[i];
|
|
if (entry == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (entry.unlockedStorySonIds == null)
|
|
{
|
|
entry.unlockedStorySonIds = new List<int>();
|
|
}
|
|
|
|
entriesByItemId[entry.storeItemId] = entry;
|
|
}
|
|
}
|
|
|
|
private StoreOwnershipPayload CreatePayload()
|
|
{
|
|
var payload = StoreOwnershipStorage.CreateDefaultPayload();
|
|
foreach (var pair in entriesByItemId)
|
|
{
|
|
payload.entries.Add(CloneEntry(pair.Value));
|
|
}
|
|
|
|
return payload;
|
|
}
|
|
|
|
private void LoadStoreItems()
|
|
{
|
|
cachedStoreItems.Clear();
|
|
var loadedItems = RuntimeResourcesCache.LoadAllStoreItems();
|
|
var seen = new HashSet<int>();
|
|
for (int i = 0; i < loadedItems.Length; i++)
|
|
{
|
|
var item = loadedItems[i];
|
|
if (item == null || !seen.Add(item.itemID))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
cachedStoreItems.Add(item);
|
|
}
|
|
}
|
|
|
|
private bool SeedFromCurrentMirrorFlags()
|
|
{
|
|
bool changed = false;
|
|
for (int i = 0; i < cachedStoreItems.Count; i++)
|
|
{
|
|
var item = cachedStoreItems[i];
|
|
if (item == null || entriesByItemId.ContainsKey(item.itemID))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
StoreOwnershipEntry seededEntry = TrySeedEntry(item);
|
|
if (seededEntry == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
entriesByItemId[item.itemID] = seededEntry;
|
|
changed = true;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
private StoreOwnershipEntry TrySeedEntry(storeItemSO itemSO)
|
|
{
|
|
if (itemSO == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
switch (itemSO.itemType)
|
|
{
|
|
case storeItemSO.ItemType.character:
|
|
if (itemSO.associatedAllyHero != null && itemSO.associatedAllyHero.isUnlocked)
|
|
{
|
|
return new StoreOwnershipEntry { storeItemId = itemSO.itemID, owned = true };
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.ItemType.song:
|
|
if (itemSO.associatedSong != null && itemSO.associatedSong.isUnlocked)
|
|
{
|
|
return new StoreOwnershipEntry { storeItemId = itemSO.itemID, owned = true };
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.ItemType.storyPassage:
|
|
return TrySeedStoryEntry(itemSO);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private StoreOwnershipEntry TrySeedStoryEntry(storeItemSO itemSO)
|
|
{
|
|
var story = itemSO != null ? itemSO.associatedStoryPassage : null;
|
|
if (story == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var entry = new StoreOwnershipEntry { storeItemId = itemSO.itemID };
|
|
switch (itemSO.storyPassageGrantMode)
|
|
{
|
|
case storeItemSO.StoryPassageGrantMode.fatherOnly:
|
|
entry.owned = story.isUnlocked;
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.specificSonOnly:
|
|
if (HasStorySonUnlocked(story, itemSO.associatedStorySonId))
|
|
{
|
|
entry.unlockedStorySonIds.Add(itemSO.associatedStorySonId);
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.fatherAndSpecificSon:
|
|
if (story.isUnlocked || HasStorySonUnlocked(story, itemSO.associatedStorySonId))
|
|
{
|
|
entry.owned = true;
|
|
if (itemSO.associatedStorySonId >= 0)
|
|
{
|
|
entry.unlockedStorySonIds.Add(itemSO.associatedStorySonId);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.allSons:
|
|
if (story.isUnlocked || AreAllStorySonsUnlocked(story))
|
|
{
|
|
entry.owned = true;
|
|
AddAllStorySonIds(story, entry.unlockedStorySonIds);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return entry.owned || entry.unlockedStorySonIds.Count > 0 ? entry : null;
|
|
}
|
|
|
|
private void SyncAllMirrorFlags()
|
|
{
|
|
ResetAllMirrorFlags();
|
|
|
|
for (int i = 0; i < cachedStoreItems.Count; i++)
|
|
{
|
|
var item = cachedStoreItems[i];
|
|
if (item == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
StoreOwnershipEntry entry;
|
|
if (!entriesByItemId.TryGetValue(item.itemID, out entry))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ApplyEntryToItem(item, entry);
|
|
}
|
|
}
|
|
|
|
private void ResetAllMirrorFlags()
|
|
{
|
|
var seenHeroIds = new HashSet<int>();
|
|
var seenSongIds = new HashSet<int>();
|
|
var seenStoryIds = new HashSet<int>();
|
|
|
|
for (int i = 0; i < cachedStoreItems.Count; i++)
|
|
{
|
|
var item = cachedStoreItems[i];
|
|
if (item == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (item.itemType == storeItemSO.ItemType.character && item.associatedAllyHero != null && seenHeroIds.Add(item.associatedAllyHero.ally_heroID))
|
|
{
|
|
if (item.associatedAllyHero.isUnlocked)
|
|
{
|
|
item.associatedAllyHero.isUnlocked = false;
|
|
MarkDirty(item.associatedAllyHero);
|
|
}
|
|
}
|
|
else if (item.itemType == storeItemSO.ItemType.song && item.associatedSong != null && seenSongIds.Add(item.associatedSong.songID))
|
|
{
|
|
if (item.associatedSong.isUnlocked)
|
|
{
|
|
item.associatedSong.isUnlocked = false;
|
|
MarkDirty(item.associatedSong);
|
|
}
|
|
}
|
|
else if (item.itemType == storeItemSO.ItemType.storyPassage && item.associatedStoryPassage != null && seenStoryIds.Add(item.associatedStoryPassage.class_id))
|
|
{
|
|
var story = item.associatedStoryPassage;
|
|
bool changed = false;
|
|
|
|
if (story.isUnlocked)
|
|
{
|
|
story.isUnlocked = false;
|
|
changed = true;
|
|
}
|
|
|
|
if (story.sonList != null)
|
|
{
|
|
for (int sonIndex = 0; sonIndex < story.sonList.Count; sonIndex++)
|
|
{
|
|
var son = story.sonList[sonIndex];
|
|
if (son != null && son.son_isUnlocked)
|
|
{
|
|
son.son_isUnlocked = false;
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
MarkDirty(story);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool ValidateGrantTarget(storeItemSO itemSO, out string failureMessage)
|
|
{
|
|
failureMessage = string.Empty;
|
|
if (itemSO == null)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.item_data_missing", "商品数据丢失");
|
|
return false;
|
|
}
|
|
|
|
if (IsOwned(itemSO))
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.item_already_unlocked", "物品已解锁");
|
|
return false;
|
|
}
|
|
|
|
switch (itemSO.itemType)
|
|
{
|
|
case storeItemSO.ItemType.character:
|
|
if (itemSO.associatedAllyHero == null)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.character_data_missing", "角色数据未配置");
|
|
return false;
|
|
}
|
|
return true;
|
|
|
|
case storeItemSO.ItemType.song:
|
|
if (itemSO.associatedSong == null)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.song_data_missing", "歌曲数据未配置");
|
|
return false;
|
|
}
|
|
return true;
|
|
|
|
case storeItemSO.ItemType.storyPassage:
|
|
if (itemSO.associatedStoryPassage == null)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.story_data_missing", "剧情数据未配置");
|
|
return false;
|
|
}
|
|
|
|
if (RequiresSpecificStorySon(itemSO.storyPassageGrantMode))
|
|
{
|
|
if (itemSO.associatedStorySonId < 0 || FindStorySonIndex(itemSO.associatedStoryPassage, itemSO.associatedStorySonId) < 0)
|
|
{
|
|
failureMessage = LocalizationService.Get("store.error.story_chapter_missing", "剧情子章节未配置");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
default:
|
|
failureMessage = LocalizationService.Get("store.error.grant_logic_missing", "当前未配置发放逻辑");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void GrantStoryOwnership(storeItemSO itemSO, StoreOwnershipEntry entry)
|
|
{
|
|
if (entry.unlockedStorySonIds == null)
|
|
{
|
|
entry.unlockedStorySonIds = new List<int>();
|
|
}
|
|
|
|
switch (itemSO.storyPassageGrantMode)
|
|
{
|
|
case storeItemSO.StoryPassageGrantMode.fatherOnly:
|
|
entry.owned = true;
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.specificSonOnly:
|
|
AddStorySonId(entry.unlockedStorySonIds, itemSO.associatedStorySonId);
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.fatherAndSpecificSon:
|
|
entry.owned = true;
|
|
AddStorySonId(entry.unlockedStorySonIds, itemSO.associatedStorySonId);
|
|
break;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.allSons:
|
|
entry.owned = true;
|
|
AddAllStorySonIds(itemSO.associatedStoryPassage, entry.unlockedStorySonIds);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ApplyEntryToItem(storeItemSO itemSO, StoreOwnershipEntry entry)
|
|
{
|
|
if (itemSO == null || entry == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (itemSO.itemType)
|
|
{
|
|
case storeItemSO.ItemType.character:
|
|
if (entry.owned && itemSO.associatedAllyHero != null)
|
|
{
|
|
itemSO.associatedAllyHero.isUnlocked = true;
|
|
itemSO.associatedAllyHero.SetJoinDateIfMissing();
|
|
MarkDirty(itemSO.associatedAllyHero);
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.ItemType.song:
|
|
if (entry.owned && itemSO.associatedSong != null)
|
|
{
|
|
itemSO.associatedSong.isUnlocked = true;
|
|
MarkDirty(itemSO.associatedSong);
|
|
}
|
|
break;
|
|
|
|
case storeItemSO.ItemType.storyPassage:
|
|
ApplyStoryEntry(itemSO.associatedStoryPassage, entry);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ApplyStoryEntry(notebook_faterType story, StoreOwnershipEntry entry)
|
|
{
|
|
if (story == null || entry == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (entry.owned || (entry.unlockedStorySonIds != null && entry.unlockedStorySonIds.Count > 0))
|
|
{
|
|
story.isUnlocked = true;
|
|
MarkDirty(story);
|
|
}
|
|
|
|
if (entry.unlockedStorySonIds == null || story.sonList == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < entry.unlockedStorySonIds.Count; i++)
|
|
{
|
|
int targetSonId = entry.unlockedStorySonIds[i];
|
|
int sonIndex = FindStorySonIndex(story, targetSonId);
|
|
if (sonIndex < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
story.sonList[sonIndex].son_isUnlocked = true;
|
|
MarkDirty(story);
|
|
}
|
|
}
|
|
|
|
private bool IsStoryGrantOwned(storeItemSO itemSO, StoreOwnershipEntry entry)
|
|
{
|
|
if (itemSO == null || itemSO.associatedStoryPassage == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (itemSO.storyPassageGrantMode)
|
|
{
|
|
case storeItemSO.StoryPassageGrantMode.fatherOnly:
|
|
return entry != null && entry.owned;
|
|
|
|
case storeItemSO.StoryPassageGrantMode.specificSonOnly:
|
|
return HasEntryStorySon(entry, itemSO.associatedStorySonId)
|
|
|| HasStorySonUnlocked(itemSO.associatedStoryPassage, itemSO.associatedStorySonId);
|
|
|
|
case storeItemSO.StoryPassageGrantMode.fatherAndSpecificSon:
|
|
return (entry != null && entry.owned)
|
|
|| HasEntryStorySon(entry, itemSO.associatedStorySonId)
|
|
|| HasStorySonUnlocked(itemSO.associatedStoryPassage, itemSO.associatedStorySonId);
|
|
|
|
case storeItemSO.StoryPassageGrantMode.allSons:
|
|
return (entry != null && entry.owned) || AreAllStorySonsUnlocked(itemSO.associatedStoryPassage);
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool HasEntryStorySon(StoreOwnershipEntry entry, int sonId)
|
|
{
|
|
if (entry == null || entry.unlockedStorySonIds == null || sonId < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < entry.unlockedStorySonIds.Count; i++)
|
|
{
|
|
if (entry.unlockedStorySonIds[i] == sonId)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool HasStorySonUnlocked(notebook_faterType story, int sonId)
|
|
{
|
|
int index = FindStorySonIndex(story, sonId);
|
|
return index >= 0 && story.sonList[index].son_isUnlocked;
|
|
}
|
|
|
|
private static bool AreAllStorySonsUnlocked(notebook_faterType story)
|
|
{
|
|
if (story == null || story.sonList == null || story.sonList.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < story.sonList.Count; i++)
|
|
{
|
|
var son = story.sonList[i];
|
|
if (son == null || !son.son_isUnlocked)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static int FindStorySonIndex(notebook_faterType story, int sonId)
|
|
{
|
|
if (story == null || story.sonList == null || sonId < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
for (int i = 0; i < story.sonList.Count; i++)
|
|
{
|
|
var son = story.sonList[i];
|
|
if (son != null && son.son_id == sonId)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private static bool RequiresSpecificStorySon(storeItemSO.StoryPassageGrantMode mode)
|
|
{
|
|
return mode == storeItemSO.StoryPassageGrantMode.specificSonOnly
|
|
|| mode == storeItemSO.StoryPassageGrantMode.fatherAndSpecificSon;
|
|
}
|
|
|
|
private static void AddStorySonId(List<int> sonIds, int sonId)
|
|
{
|
|
if (sonIds == null || sonId < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < sonIds.Count; i++)
|
|
{
|
|
if (sonIds[i] == sonId)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
sonIds.Add(sonId);
|
|
}
|
|
|
|
private static void AddAllStorySonIds(notebook_faterType story, List<int> sonIds)
|
|
{
|
|
if (story == null || story.sonList == null || sonIds == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < story.sonList.Count; i++)
|
|
{
|
|
var son = story.sonList[i];
|
|
if (son == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddStorySonId(sonIds, son.son_id);
|
|
}
|
|
}
|
|
|
|
private StoreOwnershipEntry GetOrCreateEntry(int storeItemId)
|
|
{
|
|
StoreOwnershipEntry entry;
|
|
if (entriesByItemId.TryGetValue(storeItemId, out entry))
|
|
{
|
|
return entry;
|
|
}
|
|
|
|
entry = new StoreOwnershipEntry
|
|
{
|
|
storeItemId = storeItemId,
|
|
owned = false,
|
|
unlockedStorySonIds = new List<int>()
|
|
};
|
|
entriesByItemId[storeItemId] = entry;
|
|
return entry;
|
|
}
|
|
|
|
private static StoreOwnershipEntry CloneEntry(StoreOwnershipEntry source)
|
|
{
|
|
return new StoreOwnershipEntry
|
|
{
|
|
storeItemId = source.storeItemId,
|
|
owned = source.owned,
|
|
unlockedStorySonIds = source.unlockedStorySonIds != null
|
|
? new List<int>(source.unlockedStorySonIds)
|
|
: new List<int>()
|
|
};
|
|
}
|
|
|
|
private static void MarkDirty(UnityEngine.Object target)
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (!Application.isPlaying && target != null)
|
|
{
|
|
EditorUtility.SetDirty(target);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private void NotifyOwnershipChanged(int itemId)
|
|
{
|
|
if (itemId <= 0 || OnOwnershipChanged == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
OnOwnershipChanged(itemId);
|
|
}
|
|
}
|