525 lines
20 KiB
C#
525 lines
20 KiB
C#
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using System.Collections.Generic;
|
|
using DG.Tweening;
|
|
using UnityEngine.EventSystems;
|
|
|
|
public class notebookController : MonoBehaviour
|
|
{
|
|
[Header("select father types")]
|
|
public Toggle all_content_beforeAnything_toggle;
|
|
public Toggle idols_toggle;
|
|
public Toggle enemies_toggle;
|
|
public Toggle organizations_toggle;
|
|
public Toggle areas_toggle;
|
|
public Toggle terminologies_toggle;
|
|
public Toggle Logs_toggle;
|
|
public ToggleGroup categoryToggleGroup;
|
|
|
|
[Header("quit")]
|
|
public Button quit_button;
|
|
|
|
[Header("prefabs")]
|
|
public GameObject fatherItem_prefab;
|
|
public GameObject svContent;
|
|
|
|
[Header("paths")]
|
|
[SerializeField] private string editor_SO_path;
|
|
[SerializeField] private string runtime_SO_path;
|
|
|
|
[Header("Details Displaying")]
|
|
public Image detailsImage;
|
|
public Text passage_title;
|
|
public Text passage_text;
|
|
[SerializeField] float panel_Enter_Time = 0.35f;
|
|
[SerializeField] float panel_Exit_Time = 0.25f;
|
|
[SerializeField] float panel_Enter_Scale_From = 0.92f;
|
|
[SerializeField] float panel_Exit_Scale_To = 0.9f;
|
|
[SerializeField] Ease panel_Enter_Ease = Ease.OutCubic;
|
|
[SerializeField] Ease panel_Exit_Ease = Ease.InCubic;
|
|
|
|
private readonly List<notebook_faterType> cachedItems = new List<notebook_faterType>();
|
|
private Toggle[] categoryToggles;
|
|
private readonly Dictionary<RectTransform, Vector2> fatherBaseAnchors = new Dictionary<RectTransform, Vector2>();
|
|
private readonly Dictionary<Toggle, int> toggleInvokeFrame = new Dictionary<Toggle, int>();
|
|
private readonly Dictionary<fatherItemPrefab, LayoutElement> fatherSpacers = new Dictionary<fatherItemPrefab, LayoutElement>();
|
|
private readonly Dictionary<fatherItemPrefab, int> fatherAnimTokens = new Dictionary<fatherItemPrefab, int>();
|
|
private bool initialized = false;
|
|
private const float SonOffsetBase = 5f;
|
|
private const float SonOffsetPerItem = 110f;
|
|
private const float SonTweenDuration = 0.5f;
|
|
private const float SonFadeDuration = 0.25f;
|
|
|
|
private void Start()
|
|
{
|
|
Initialize();
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
Initialize();
|
|
PlayEnterAnim();
|
|
}
|
|
|
|
private void Initialize()
|
|
{
|
|
if (initialized) return;
|
|
initialized = true;
|
|
StoreOwnershipLedger.EnsureInstance().InitializeIfNeeded();
|
|
LoadAllData();
|
|
categoryToggles = new[]
|
|
{
|
|
all_content_beforeAnything_toggle,
|
|
idols_toggle,
|
|
enemies_toggle,
|
|
organizations_toggle,
|
|
areas_toggle,
|
|
terminologies_toggle,
|
|
Logs_toggle
|
|
};
|
|
categoryToggleGroup = ResolveCategoryToggleGroup();
|
|
if (categoryToggleGroup != null)
|
|
categoryToggleGroup.allowSwitchOff = true;
|
|
if (categoryToggles != null)
|
|
{
|
|
for (int i = 0; i < categoryToggles.Length; i++)
|
|
{
|
|
var t = categoryToggles[i];
|
|
if (t == null) continue;
|
|
t.group = categoryToggleGroup;
|
|
}
|
|
}
|
|
BindToggle(all_content_beforeAnything_toggle, () => Refresh(notebook_faterType.notebook_fatherType.content));
|
|
BindToggle(idols_toggle, () => Refresh(notebook_faterType.notebook_fatherType.idols));
|
|
BindToggle(enemies_toggle, () => Refresh(notebook_faterType.notebook_fatherType.enemies));
|
|
BindToggle(organizations_toggle, () => Refresh(notebook_faterType.notebook_fatherType.organizations));
|
|
BindToggle(areas_toggle, () => Refresh(notebook_faterType.notebook_fatherType.areas));
|
|
BindToggle(terminologies_toggle, () => Refresh(notebook_faterType.notebook_fatherType.terminologies));
|
|
BindToggle(Logs_toggle, () => Refresh(notebook_faterType.notebook_fatherType.Logs));
|
|
if (quit_button != null)
|
|
{
|
|
quit_button.onClick.RemoveAllListeners();
|
|
quit_button.onClick.AddListener(CloseSelf);
|
|
}
|
|
if (all_content_beforeAnything_toggle != null)
|
|
all_content_beforeAnything_toggle.isOn = true;
|
|
Refresh(notebook_faterType.notebook_fatherType.content);
|
|
}
|
|
|
|
private void BindToggle(Toggle toggle, System.Action onSelected)
|
|
{
|
|
if (toggle == null) return;
|
|
toggle.onValueChanged.RemoveAllListeners();
|
|
toggle.onValueChanged.AddListener(isOn =>
|
|
{
|
|
if (isOn) InvokeToggleAction(toggle, onSelected);
|
|
});
|
|
var relay = toggle.GetComponent<ToggleClickRelay>();
|
|
if (relay == null) relay = toggle.gameObject.AddComponent<ToggleClickRelay>();
|
|
relay.onClick = () =>
|
|
{
|
|
if (toggle != null && toggle.isOn) InvokeToggleAction(toggle, onSelected);
|
|
};
|
|
}
|
|
|
|
private ToggleGroup ResolveCategoryToggleGroup()
|
|
{
|
|
if (categoryToggleGroup != null) return categoryToggleGroup;
|
|
Toggle first = null;
|
|
if (categoryToggles != null)
|
|
{
|
|
for (int i = 0; i < categoryToggles.Length; i++)
|
|
{
|
|
if (categoryToggles[i] != null) { first = categoryToggles[i]; break; }
|
|
}
|
|
}
|
|
if (first == null) return null;
|
|
var parentGroup = first.GetComponentInParent<ToggleGroup>();
|
|
var contentGroup = svContent != null ? svContent.GetComponent<ToggleGroup>() : null;
|
|
if (parentGroup != null && parentGroup != contentGroup) return parentGroup;
|
|
var parent = first.transform.parent;
|
|
if (parent == null) return null;
|
|
var created = parent.GetComponent<ToggleGroup>();
|
|
if (created == null) created = parent.gameObject.AddComponent<ToggleGroup>();
|
|
return created;
|
|
}
|
|
|
|
private void LoadAllData()
|
|
{
|
|
cachedItems.Clear();
|
|
var set = new HashSet<notebook_faterType>();
|
|
#if UNITY_EDITOR
|
|
if (!string.IsNullOrEmpty(editor_SO_path))
|
|
{
|
|
var guids = UnityEditor.AssetDatabase.FindAssets("t:notebook_faterType", new[] { editor_SO_path });
|
|
for (int i = 0; i < guids.Length; i++)
|
|
{
|
|
var path = UnityEditor.AssetDatabase.GUIDToAssetPath(guids[i]);
|
|
var so = UnityEditor.AssetDatabase.LoadAssetAtPath<notebook_faterType>(path);
|
|
if (so == null) continue;
|
|
if (set.Add(so)) cachedItems.Add(so);
|
|
}
|
|
}
|
|
#endif
|
|
if (!string.IsNullOrEmpty(runtime_SO_path))
|
|
{
|
|
var resources = Resources.LoadAll<notebook_faterType>(runtime_SO_path);
|
|
for (int i = 0; i < resources.Length; i++)
|
|
{
|
|
var so = resources[i];
|
|
if (so == null) continue;
|
|
if (set.Add(so)) cachedItems.Add(so);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Refresh(notebook_faterType.notebook_fatherType? type)
|
|
{
|
|
if (fatherItem_prefab == null || svContent == null) return;
|
|
ClearContent();
|
|
var fatherGroup = svContent.GetComponent<ToggleGroup>();
|
|
if (fatherGroup == categoryToggleGroup) fatherGroup = null;
|
|
for (int i = 0; i < cachedItems.Count; i++)
|
|
{
|
|
var so = cachedItems[i];
|
|
if (so == null) continue;
|
|
if (!so.isUnlocked) continue;
|
|
if (type.HasValue && so.fatherType != type.Value) continue;
|
|
var obj = Instantiate(fatherItem_prefab, svContent.transform);
|
|
var comp = obj.GetComponent<fatherItemPrefab>();
|
|
if (comp == null) continue;
|
|
if (comp.father_name != null) comp.father_name.text = so.class_name;
|
|
if (comp.father_img != null) comp.father_img.sprite = so.class_image;
|
|
if (comp.father_description != null) comp.father_description.text = so.class_description;
|
|
SetupFatherItem(comp, so, fatherGroup);
|
|
}
|
|
CacheFatherBasePositions();
|
|
}
|
|
|
|
private void SetupFatherItem(fatherItemPrefab comp, notebook_faterType so, ToggleGroup fatherGroup)
|
|
{
|
|
if (comp == null) return;
|
|
ClearSonContainer(comp);
|
|
if (comp.son_obj != null) comp.son_obj.SetActive(false);
|
|
if (comp.son_prefab_toPut != null) comp.son_prefab_toPut.SetActive(false);
|
|
Toggle toggle = null;
|
|
if (comp.father_obj != null) toggle = comp.father_obj.GetComponent<Toggle>();
|
|
if (toggle == null) toggle = comp.GetComponent<Toggle>();
|
|
if (toggle == null) toggle = comp.GetComponentInChildren<Toggle>(true);
|
|
if (toggle == null) toggle = comp.GetComponentInParent<Toggle>();
|
|
if (toggle == null) return;
|
|
if (fatherGroup != null) toggle.group = fatherGroup;
|
|
toggle.onValueChanged.RemoveAllListeners();
|
|
toggle.onValueChanged.AddListener(isOn =>
|
|
{
|
|
ApplySonState(comp, so, isOn);
|
|
});
|
|
ApplySonState(comp, so, toggle.isOn);
|
|
}
|
|
|
|
private void ApplySonState(fatherItemPrefab comp, notebook_faterType so, bool isOn)
|
|
{
|
|
if (comp == null) return;
|
|
int token = NextAnimToken(comp);
|
|
if (isOn)
|
|
{
|
|
EnsureSonsLoaded(comp, so);
|
|
UpdateFatherSpacer(comp, so, true, token);
|
|
FadeSonContainer(comp, true, token, null);
|
|
}
|
|
else
|
|
{
|
|
FadeSonContainer(comp, false, token, () => ClearSonContainer(comp));
|
|
UpdateFatherSpacer(comp, so, false, token);
|
|
}
|
|
}
|
|
|
|
private void EnsureSonsLoaded(fatherItemPrefab comp, notebook_faterType so)
|
|
{
|
|
if (comp == null || so == null) return;
|
|
if (comp.son_prefab == null || comp.son_prefab_toPut == null) return;
|
|
if (so.sonList == null || so.sonList.Count == 0) return;
|
|
ClearSonContainer(comp);
|
|
var parent = comp.son_prefab_toPut.transform;
|
|
var prefab = comp.son_prefab;
|
|
ToggleGroup sonGroup = null;
|
|
if (comp.son_prefab_toPut != null) sonGroup = comp.son_prefab_toPut.GetComponent<ToggleGroup>();
|
|
if (sonGroup == null && comp.son_obj != null) sonGroup = comp.son_obj.GetComponent<ToggleGroup>();
|
|
for (int i = 0; i < so.sonList.Count; i++)
|
|
{
|
|
var son = so.sonList[i];
|
|
if (son == null) continue;
|
|
if (!son.son_isUnlocked) continue;
|
|
var obj = Instantiate(prefab, parent);
|
|
var sonComp = obj.GetComponent<sonItemPrefab>();
|
|
Toggle sonToggle = null;
|
|
if (sonComp != null && sonComp.sonToggle != null) sonToggle = sonComp.sonToggle;
|
|
if (sonToggle == null) sonToggle = obj.GetComponent<Toggle>();
|
|
if (sonToggle == null) sonToggle = obj.GetComponentInChildren<Toggle>(true);
|
|
if (sonGroup != null && sonToggle != null) sonToggle.group = sonGroup;
|
|
if (sonComp == null) continue;
|
|
if (sonComp.sonName != null) sonComp.sonName.text = son.son_name;
|
|
if (sonComp.sonDescription != null) sonComp.sonDescription.text = son.son_description;
|
|
if (sonComp.sonImage != null) sonComp.sonImage.sprite = son.son_image;
|
|
if (sonToggle != null)
|
|
{
|
|
sonToggle.onValueChanged.RemoveAllListeners();
|
|
sonToggle.onValueChanged.AddListener(isOn =>
|
|
{
|
|
if (isOn) ApplySonDetails(son);
|
|
});
|
|
if (sonToggle.isOn) ApplySonDetails(son);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplySonDetails(notebook_faterType.notebook_sonClass son)
|
|
{
|
|
if (son == null) return;
|
|
if (detailsImage != null) detailsImage.sprite = son.son_image;
|
|
if (passage_title != null) passage_title.text = son.son_title;
|
|
if (passage_text != null) passage_text.text = son.son_passage;
|
|
}
|
|
|
|
private void InvokeToggleAction(Toggle toggle, System.Action onSelected)
|
|
{
|
|
if (toggle == null || onSelected == null) return;
|
|
int frame = Time.frameCount;
|
|
if (toggleInvokeFrame.TryGetValue(toggle, out var lastFrame) && lastFrame == frame) return;
|
|
toggleInvokeFrame[toggle] = frame;
|
|
onSelected.Invoke();
|
|
}
|
|
|
|
private class ToggleClickRelay : MonoBehaviour, IPointerClickHandler
|
|
{
|
|
public System.Action onClick;
|
|
public void OnPointerClick(PointerEventData eventData)
|
|
{
|
|
onClick?.Invoke();
|
|
}
|
|
}
|
|
|
|
private void CacheFatherBasePositions()
|
|
{
|
|
if (svContent == null) return;
|
|
var parent = svContent.transform as RectTransform;
|
|
if (parent == null) return;
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(parent);
|
|
fatherBaseAnchors.Clear();
|
|
for (int i = 0; i < parent.childCount; i++)
|
|
{
|
|
var child = parent.GetChild(i) as RectTransform;
|
|
if (child == null) continue;
|
|
fatherBaseAnchors[child] = child.anchoredPosition;
|
|
}
|
|
}
|
|
|
|
private void UpdateFatherSpacer(fatherItemPrefab comp, notebook_faterType so, bool expand, int token)
|
|
{
|
|
if (svContent == null || comp == null) return;
|
|
var parent = svContent.transform as RectTransform;
|
|
if (parent == null) return;
|
|
int count = expand ? GetUnlockedSonCount(so) : 0;
|
|
float targetHeight = count > 0 ? (SonOffsetBase + (SonOffsetPerItem * count)) : 0f;
|
|
if (!fatherSpacers.TryGetValue(comp, out var spacer) || spacer == null)
|
|
{
|
|
if (!expand) return;
|
|
var spacerObj = new GameObject("NotebookSpacer", typeof(RectTransform), typeof(LayoutElement));
|
|
spacerObj.transform.SetParent(parent, false);
|
|
spacer = spacerObj.GetComponent<LayoutElement>();
|
|
spacer.minHeight = 0f;
|
|
spacer.flexibleHeight = 0f;
|
|
spacer.preferredHeight = 0f;
|
|
var spacerRectInit = spacerObj.transform as RectTransform;
|
|
if (spacerRectInit != null)
|
|
{
|
|
spacerRectInit.pivot = new Vector2(0.5f, 1f);
|
|
spacerRectInit.sizeDelta = new Vector2(spacerRectInit.sizeDelta.x, 0f);
|
|
}
|
|
fatherSpacers[comp] = spacer;
|
|
}
|
|
var spacerRect = spacer.transform as RectTransform;
|
|
int targetIndex = comp.transform.GetSiblingIndex() + 1;
|
|
if (spacerRect != null && spacerRect.GetSiblingIndex() != targetIndex)
|
|
spacerRect.SetSiblingIndex(targetIndex);
|
|
DOTween.Kill(spacer, false);
|
|
if (expand)
|
|
{
|
|
DOTween.To(() => spacer.preferredHeight, h =>
|
|
{
|
|
spacer.preferredHeight = h;
|
|
spacer.minHeight = h;
|
|
if (spacerRect != null)
|
|
spacerRect.sizeDelta = new Vector2(spacerRect.sizeDelta.x, h);
|
|
}, targetHeight, SonTweenDuration)
|
|
.SetTarget(spacer)
|
|
.SetEase(Ease.OutCubic)
|
|
.OnUpdate(() => LayoutRebuilder.ForceRebuildLayoutImmediate(parent));
|
|
}
|
|
else
|
|
{
|
|
DOTween.To(() => spacer.preferredHeight, h =>
|
|
{
|
|
spacer.preferredHeight = h;
|
|
spacer.minHeight = h;
|
|
if (spacerRect != null)
|
|
spacerRect.sizeDelta = new Vector2(spacerRect.sizeDelta.x, h);
|
|
}, 0f, SonTweenDuration)
|
|
.SetTarget(spacer)
|
|
.SetEase(Ease.OutCubic)
|
|
.OnUpdate(() => LayoutRebuilder.ForceRebuildLayoutImmediate(parent))
|
|
.OnComplete(() =>
|
|
{
|
|
if (!IsTokenCurrent(comp, token)) return;
|
|
if (spacer != null)
|
|
{
|
|
fatherSpacers.Remove(comp);
|
|
if (Application.isPlaying) Destroy(spacer.gameObject);
|
|
else DestroyImmediate(spacer.gameObject);
|
|
}
|
|
});
|
|
}
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(parent);
|
|
}
|
|
|
|
private void FadeSonContainer(fatherItemPrefab comp, bool show, int token, System.Action onComplete)
|
|
{
|
|
var rect = GetSonRect(comp);
|
|
if (rect == null)
|
|
{
|
|
onComplete?.Invoke();
|
|
return;
|
|
}
|
|
rect.DOKill();
|
|
if (show)
|
|
{
|
|
rect.gameObject.SetActive(true);
|
|
var cg = rect.GetComponent<CanvasGroup>();
|
|
if (cg == null) cg = rect.gameObject.AddComponent<CanvasGroup>();
|
|
cg.alpha = 0f;
|
|
cg.DOKill();
|
|
cg.DOFade(1f, SonFadeDuration).SetTarget(cg).SetEase(Ease.OutCubic);
|
|
}
|
|
else
|
|
{
|
|
var cg = rect.GetComponent<CanvasGroup>();
|
|
if (cg == null)
|
|
{
|
|
rect.gameObject.SetActive(false);
|
|
onComplete?.Invoke();
|
|
return;
|
|
}
|
|
cg.DOKill();
|
|
cg.DOFade(0f, SonFadeDuration).SetTarget(cg).SetEase(Ease.OutCubic).OnComplete(() =>
|
|
{
|
|
if (!IsTokenCurrent(comp, token)) return;
|
|
rect.gameObject.SetActive(false);
|
|
onComplete?.Invoke();
|
|
});
|
|
}
|
|
}
|
|
|
|
private int NextAnimToken(fatherItemPrefab comp)
|
|
{
|
|
if (comp == null) return 0;
|
|
if (!fatherAnimTokens.TryGetValue(comp, out var token)) token = 0;
|
|
token++;
|
|
fatherAnimTokens[comp] = token;
|
|
return token;
|
|
}
|
|
|
|
private bool IsTokenCurrent(fatherItemPrefab comp, int token)
|
|
{
|
|
if (comp == null) return false;
|
|
return fatherAnimTokens.TryGetValue(comp, out var current) && current == token;
|
|
}
|
|
|
|
private RectTransform GetSonRect(fatherItemPrefab comp)
|
|
{
|
|
if (comp == null) return null;
|
|
if (comp.son_prefab_toPut != null) return comp.son_prefab_toPut.transform as RectTransform;
|
|
if (comp.son_obj != null) return comp.son_obj.transform as RectTransform;
|
|
return null;
|
|
}
|
|
|
|
private int GetUnlockedSonCount(notebook_faterType so)
|
|
{
|
|
if (so == null || so.sonList == null) return 0;
|
|
int count = 0;
|
|
for (int i = 0; i < so.sonList.Count; i++)
|
|
{
|
|
var son = so.sonList[i];
|
|
if (son == null) continue;
|
|
if (!son.son_isUnlocked) continue;
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
private void PlayEnterAnim()
|
|
{
|
|
var rect = transform as RectTransform;
|
|
if (rect == null) rect = GetComponent<RectTransform>();
|
|
if (rect == null) return;
|
|
rect.DOKill();
|
|
var cg = GetComponent<CanvasGroup>();
|
|
if (cg == null) cg = gameObject.AddComponent<CanvasGroup>();
|
|
cg.DOKill();
|
|
rect.localScale = Vector3.one * panel_Enter_Scale_From;
|
|
cg.alpha = 0f;
|
|
rect.DOScale(Vector3.one, panel_Enter_Time).SetEase(panel_Enter_Ease);
|
|
cg.DOFade(1f, panel_Enter_Time).SetEase(panel_Enter_Ease);
|
|
}
|
|
|
|
private void CloseSelf()
|
|
{
|
|
var rect = transform as RectTransform;
|
|
if (rect == null) rect = GetComponent<RectTransform>();
|
|
if (rect == null)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
rect.DOKill();
|
|
var cg = GetComponent<CanvasGroup>();
|
|
if (cg == null) cg = gameObject.AddComponent<CanvasGroup>();
|
|
cg.DOKill();
|
|
Sequence seq = DOTween.Sequence();
|
|
seq.Join(rect.DOScale(Vector3.one * panel_Exit_Scale_To, panel_Exit_Time).SetEase(panel_Exit_Ease));
|
|
seq.Join(cg.DOFade(0f, panel_Exit_Time).SetEase(panel_Exit_Ease));
|
|
seq.OnComplete(() =>
|
|
{
|
|
if (this != null) Destroy(gameObject);
|
|
});
|
|
}
|
|
|
|
private void ClearSonContainer(fatherItemPrefab comp)
|
|
{
|
|
if (comp == null || comp.son_prefab_toPut == null) return;
|
|
var parent = comp.son_prefab_toPut.transform;
|
|
var rect = parent as RectTransform;
|
|
if (rect != null) rect.DOKill();
|
|
for (int i = parent.childCount - 1; i >= 0; i--)
|
|
{
|
|
var child = parent.GetChild(i);
|
|
if (child == null) continue;
|
|
if (Application.isPlaying) Destroy(child.gameObject);
|
|
else DestroyImmediate(child.gameObject);
|
|
}
|
|
}
|
|
|
|
private void ClearContent()
|
|
{
|
|
var parent = svContent.transform;
|
|
for (int i = parent.childCount - 1; i >= 0; i--)
|
|
{
|
|
var child = parent.GetChild(i);
|
|
if (child == null) continue;
|
|
if (Application.isPlaying) Destroy(child.gameObject);
|
|
else DestroyImmediate(child.gameObject);
|
|
}
|
|
fatherBaseAnchors.Clear();
|
|
fatherSpacers.Clear();
|
|
}
|
|
}
|