r2mods/ilspy_dump/ror2_csproj/RoR2.UI.LogBook/LogBookController.cs

1658 lines
51 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using EntityStates;
using HG;
using RoR2.EntitlementManagement;
using RoR2.ExpansionManagement;
using RoR2.Stats;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
namespace RoR2.UI.LogBook;
public class LogBookController : MonoBehaviour
{
private class NavigationPageInfo
{
public CategoryDef categoryDef;
public Entry[] entries;
public int index;
public int indexInCategory;
}
private class LogBookState : EntityState
{
protected LogBookController logBookController;
protected float unscaledAge;
public override void OnEnter()
{
base.OnEnter();
logBookController = GetComponent<LogBookController>();
}
public override void Update()
{
base.Update();
unscaledAge += Time.unscaledDeltaTime;
}
}
private class FadeState : LogBookState
{
private CanvasGroup canvasGroup;
public float duration = 0.5f;
public float endValue;
public override void OnEnter()
{
base.OnEnter();
canvasGroup = GetComponent<CanvasGroup>();
if ((bool)canvasGroup)
{
canvasGroup.alpha = 0f;
}
}
public override void OnExit()
{
if ((bool)canvasGroup)
{
canvasGroup.alpha = endValue;
}
base.OnExit();
}
public override void Update()
{
if ((bool)canvasGroup)
{
canvasGroup.alpha = unscaledAge / duration;
if (canvasGroup.alpha >= 1f)
{
outer.SetNextState(new Idle());
}
}
base.Update();
}
}
private class ChangeEntriesPageState : LogBookState
{
private int oldPageIndex;
public NavigationPageInfo newNavigationPageInfo;
public float duration = 0.1f;
public Vector2 moveDirection;
private GameObject oldPage;
private GameObject newPage;
private Vector2 oldPageTargetPosition;
private Vector2 newPageTargetPosition;
private Vector2 containerSize = Vector2.zero;
public override void OnEnter()
{
base.OnEnter();
if ((bool)logBookController)
{
oldPageIndex = logBookController.currentPageIndex;
oldPage = logBookController.currentEntriesPageObject;
newPage = logBookController.BuildEntriesPage(newNavigationPageInfo);
containerSize = logBookController.entryPageContainer.rect.size;
}
SetPagePositions(0f);
}
public override void OnExit()
{
base.OnExit();
EntityState.Destroy(oldPage);
if ((bool)logBookController)
{
logBookController.currentEntriesPageObject = newPage;
logBookController.currentPageIndex = newNavigationPageInfo.indexInCategory;
}
}
private void SetPagePositions(float t)
{
Vector2 vector = new Vector2(containerSize.x * (0f - moveDirection.x), containerSize.y * moveDirection.y);
Vector2 vector2 = vector * t;
if ((bool)oldPage)
{
oldPage.transform.localPosition = vector2;
}
if ((bool)newPage)
{
newPage.transform.localPosition = vector2 - vector;
}
}
public override void Update()
{
base.Update();
float num = Mathf.Clamp01(unscaledAge / duration);
SetPagePositions(num);
if (num == 1f)
{
outer.SetNextState(new Idle());
}
}
}
private class ChangeCategoryState : LogBookState
{
private int oldCategoryIndex;
public int newCategoryIndex;
public bool goToLastPage;
public float duration = 0.1f;
private GameObject oldPage;
private GameObject newPage;
private Vector2 oldPageTargetPosition;
private Vector2 newPageTargetPosition;
private Vector2 moveDirection;
private Vector2 containerSize = Vector2.zero;
private NavigationPageInfo[] newNavigationPages;
private int destinationPageIndex;
private NavigationPageInfo newNavigationPageInfo;
private int frame;
public override void OnEnter()
{
base.OnEnter();
if ((bool)logBookController)
{
oldCategoryIndex = logBookController.currentCategoryIndex;
oldPage = logBookController.currentEntriesPageObject;
newNavigationPages = logBookController.GetCategoryPages(newCategoryIndex);
destinationPageIndex = newNavigationPages[0].index;
if (goToLastPage)
{
destinationPageIndex = newNavigationPages[newNavigationPages.Length - 1].index;
Debug.LogFormat("goToLastPage=true destinationPageIndex={0}", destinationPageIndex);
}
newNavigationPageInfo = logBookController.allNavigationPages[destinationPageIndex];
newPage = logBookController.BuildEntriesPage(newNavigationPageInfo);
containerSize = logBookController.entryPageContainer.rect.size;
moveDirection = new Vector2(Mathf.Sign(newCategoryIndex - oldCategoryIndex), 0f);
}
SetPagePositions(0f);
}
public override void OnExit()
{
EntityState.Destroy(oldPage);
if ((bool)logBookController)
{
logBookController.currentEntriesPageObject = newPage;
logBookController.currentPageIndex = newNavigationPageInfo.indexInCategory;
logBookController.desiredPageIndex = newNavigationPageInfo.indexInCategory;
logBookController.currentCategoryIndex = newCategoryIndex;
logBookController.availableNavigationPages = newNavigationPages;
logBookController.currentCategoryLabel.token = categories[newCategoryIndex].nameToken;
logBookController.categoryHightlightRect.SetParent(logBookController.navigationCategoryButtonAllocator.elements[newCategoryIndex].transform, worldPositionStays: false);
logBookController.categoryHightlightRect.gameObject.SetActive(value: false);
logBookController.categoryHightlightRect.gameObject.SetActive(value: true);
if (logBookController.moveNavigationPageIndicatorContainerToCategoryButton)
{
logBookController.navigationPageIndicatorContainer.SetParent(logBookController.navigationCategoryButtonAllocator.elements[newCategoryIndex].transform, worldPositionStays: false);
}
}
base.OnExit();
}
private void SetPagePositions(float t)
{
Vector2 vector = new Vector2(containerSize.x * (0f - moveDirection.x), containerSize.y * moveDirection.y);
Vector2 vector2 = vector * t;
if ((bool)oldPage)
{
oldPage.transform.localPosition = vector2;
}
if ((bool)newPage)
{
newPage.transform.localPosition = vector2 - vector;
if (frame == 4)
{
newPage.GetComponent<GridLayoutGroup>().enabled = false;
}
}
}
public override void Update()
{
base.Update();
frame++;
float num = Mathf.Clamp01(unscaledAge / duration);
SetPagePositions(num);
if (num == 1f)
{
outer.SetNextState(new Idle());
}
}
}
private class EnterLogViewState : LogBookState
{
public Texture iconTexture;
public RectTransform startRectTransform;
public RectTransform endRectTransform;
public Entry entry;
private GameObject flyingIcon;
private RectTransform flyingIconTransform;
private RawImage flyingIconImage;
private float duration = 0.75f;
private Rect startRect;
private Rect midRect;
private Rect endRect;
private bool submittedViewEntry;
public override void OnEnter()
{
base.OnEnter();
flyingIcon = new GameObject("FlyingIcon", typeof(RectTransform), typeof(CanvasRenderer), typeof(RawImage));
flyingIconTransform = (RectTransform)flyingIcon.transform;
flyingIconTransform.SetParent(logBookController.transform, worldPositionStays: false);
flyingIconTransform.localScale = Vector3.one;
flyingIconImage = flyingIconTransform.GetComponent<RawImage>();
flyingIconImage.texture = iconTexture;
Vector3[] array = new Vector3[4];
startRectTransform.GetWorldCorners(array);
startRect = GetRectRelativeToParent(array);
midRect = new Rect(((RectTransform)logBookController.transform).rect.center, startRect.size);
endRectTransform.GetWorldCorners(array);
endRect = GetRectRelativeToParent(array);
SetIconRect(startRect);
}
private void SetIconRect(Rect rect)
{
flyingIconTransform.position = rect.position;
flyingIconTransform.offsetMin = rect.min;
flyingIconTransform.offsetMax = rect.max;
}
private Rect GetRectRelativeToParent(Vector3[] corners)
{
for (int i = 0; i < 4; i++)
{
corners[i] = logBookController.transform.InverseTransformPoint(corners[i]);
}
Rect result = default(Rect);
result.xMin = corners[0].x;
result.xMax = corners[2].x;
result.yMin = corners[0].y;
result.yMax = corners[2].y;
return result;
}
private static Rect RectFromWorldCorners(Vector3[] corners)
{
Rect result = default(Rect);
result.xMin = corners[0].x;
result.xMax = corners[2].x;
result.yMin = corners[0].y;
result.yMax = corners[2].y;
return result;
}
private static Rect LerpRect(Rect a, Rect b, float t)
{
Rect result = default(Rect);
result.min = Vector2.LerpUnclamped(a.min, b.min, t);
result.max = Vector2.LerpUnclamped(a.max, b.max, t);
return result;
}
public override void OnExit()
{
EntityState.Destroy(flyingIcon);
base.OnExit();
}
public override void Update()
{
base.Update();
float num = Mathf.Min(unscaledAge / duration, 1f);
if (num < 0.1f)
{
Util.Remap(num, 0f, 0.1f, 0f, 1f);
SetIconRect(startRect);
}
if (num < 0.2f)
{
float t = Util.Remap(num, 0.1f, 0.2f, 0f, 1f);
SetIconRect(LerpRect(startRect, midRect, t));
}
else if (num < 0.4f)
{
Util.Remap(num, 0.2f, 0.4f, 0f, 1f);
SetIconRect(midRect);
}
else if (num < 0.6f)
{
float t2 = Util.Remap(num, 0.4f, 0.6f, 0f, 1f);
SetIconRect(LerpRect(midRect, endRect, t2));
}
else if (num < 1f)
{
float num2 = Util.Remap(num, 0.6f, 1f, 0f, 1f);
flyingIconImage.color = new Color(1f, 1f, 1f, 1f - num2);
SetIconRect(endRect);
if (!submittedViewEntry)
{
submittedViewEntry = true;
logBookController.ViewEntry(entry);
}
}
else
{
outer.SetNextState(new Idle());
}
}
}
[Header("Navigation")]
public GameObject navigationPanel;
public RectTransform categoryContainer;
public GameObject categorySpaceFiller;
public int categorySpaceFillerCount;
public Color spaceFillerColor;
private UIElementAllocator<MPButton> navigationCategoryButtonAllocator;
public RectTransform entryPageContainer;
public GameObject entryPagePrefab;
public RectTransform navigationPageIndicatorContainer;
public GameObject navigationPageIndicatorPrefab;
public bool moveNavigationPageIndicatorContainerToCategoryButton;
private UIElementAllocator<MPButton> navigationPageIndicatorAllocator;
public MPButton previousPageButton;
public MPButton nextPageButton;
public LanguageTextMeshController currentCategoryLabel;
private RectTransform categoryHightlightRect;
[Header("PageViewer")]
public UnityEvent OnViewEntry;
public GameObject pageViewerPanel;
public MPButton pageViewerBackButton;
[Header("Misc")]
public GameObject categoryButtonPrefab;
public GameObject headerHighlightPrefab;
public LanguageTextMeshController hoverLanguageTextMeshController;
public string hoverDescriptionFormatString;
private EntityStateMachine stateMachine;
private UILayerKey uiLayerKey;
public static CategoryDef[] categories;
public static ResourceAvailability availability;
private static bool IsInitialized;
public static bool IsStaticDataReady;
private NavigationPageInfo[] _availableNavigationPages = Array.Empty<NavigationPageInfo>();
private GameObject currentEntriesPageObject;
private int currentCategoryIndex;
private int desiredCategoryIndex;
private int currentPageIndex;
private int desiredPageIndex;
private bool goToEndOfNextCategory;
private NavigationPageInfo[] allNavigationPages;
private NavigationPageInfo[][] navigationPagesByCategory;
private static List<EntitlementDef> lastBuiltEntitlements;
private NavigationPageInfo[] availableNavigationPages
{
get
{
return _availableNavigationPages;
}
set
{
int num = _availableNavigationPages.Length;
_availableNavigationPages = value;
if (num != availableNavigationPages.Length)
{
navigationPageIndicatorAllocator.AllocateElements(availableNavigationPages.Length);
}
}
}
public static event Action OnViewablesRegistered;
private void Awake()
{
EntitlementManager.UpdateLocalUsersEntitlements();
navigationCategoryButtonAllocator = new UIElementAllocator<MPButton>(categoryContainer, categoryButtonPrefab);
navigationPageIndicatorAllocator = new UIElementAllocator<MPButton>(navigationPageIndicatorContainer, navigationPageIndicatorPrefab);
navigationPageIndicatorAllocator.onCreateElement = delegate(int index, MPButton button)
{
button.onClick.AddListener(delegate
{
desiredPageIndex = index;
});
};
previousPageButton.onClick.AddListener(OnLeftButton);
nextPageButton.onClick.AddListener(OnRightButton);
pageViewerBackButton.onClick.AddListener(ReturnToNavigation);
stateMachine = base.gameObject.AddComponent<EntityStateMachine>();
uiLayerKey = base.gameObject.GetComponent<UILayerKey>();
stateMachine.initialStateType = default(SerializableEntityStateType);
stateMachine.AllowStartWithoutNetworker = true;
stateMachine.ShouldStateTransitionOnUpdate = true;
categoryHightlightRect = (RectTransform)UnityEngine.Object.Instantiate(headerHighlightPrefab, base.transform.parent).transform;
categoryHightlightRect.gameObject.SetActive(value: false);
}
private void Start()
{
GeneratePages(LocalUserManager.GetFirstLocalUser()?.userProfile);
BuildCategoriesButtons();
stateMachine.SetNextState(new ChangeCategoryState
{
newCategoryIndex = 0
});
}
private void BuildCategoriesButtons()
{
navigationCategoryButtonAllocator.AllocateElements(categories.Length);
ReadOnlyCollection<MPButton> elements = navigationCategoryButtonAllocator.elements;
for (int i = 0; i < categories.Length; i++)
{
int categoryIndex = i;
MPButton mPButton = elements[i];
CategoryDef categoryDef = categories[i];
mPButton.GetComponentInChildren<TextMeshProUGUI>().text = Language.GetString(categoryDef.nameToken);
mPButton.onClick.RemoveAllListeners();
mPButton.onClick.AddListener(delegate
{
OnCategoryClicked(categoryIndex);
});
mPButton.requiredTopLayer = uiLayerKey;
ViewableTag viewableTag = mPButton.gameObject.GetComponent<ViewableTag>();
if (!viewableTag)
{
viewableTag = mPButton.gameObject.AddComponent<ViewableTag>();
}
viewableTag.viewableName = categoryDef.viewableNode.fullName;
}
if ((bool)categorySpaceFiller)
{
for (int j = 0; j < categorySpaceFillerCount; j++)
{
UnityEngine.Object.Instantiate(categorySpaceFiller, categoryContainer).gameObject.SetActive(value: true);
}
}
}
public static IEnumerator Init()
{
if (LocalUserManager.isAnyUserSignedIn)
{
BuildStaticData();
}
yield return null;
LocalUserManager.onUserSignIn += OnUserSignIn;
BaseUserEntitlementTracker<LocalUser>.OnUserEntitlementsUpdated = (Action)Delegate.Combine(BaseUserEntitlementTracker<LocalUser>.OnUserEntitlementsUpdated, new Action(BuildStaticData));
IsInitialized = true;
}
private static void OnUserSignIn(LocalUser obj)
{
BuildStaticData();
}
private static EntryStatus GetPickupStatus(in Entry entry, UserProfile viewerProfile)
{
UnlockableDef unlockableDef = null;
PickupIndex pickupIndex = (PickupIndex)entry.extraData;
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
ItemIndex itemIndex = pickupDef?.itemIndex ?? ItemIndex.None;
EquipmentIndex equipmentIndex = pickupDef?.equipmentIndex ?? EquipmentIndex.None;
if (itemIndex != ItemIndex.None)
{
unlockableDef = ItemCatalog.GetItemDef(itemIndex).unlockableDef;
}
else
{
if (equipmentIndex == EquipmentIndex.None)
{
return EntryStatus.Unimplemented;
}
unlockableDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex).unlockableDef;
}
if (!viewerProfile.HasUnlockable(unlockableDef))
{
return EntryStatus.Locked;
}
if (!viewerProfile.HasDiscoveredPickup(pickupIndex))
{
return EntryStatus.Unencountered;
}
return EntryStatus.Available;
}
private static TooltipContent GetPickupTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
UnlockableDef unlockableDef = PickupCatalog.GetPickupDef((PickupIndex)entry.extraData).unlockableDef;
TooltipContent result = default(TooltipContent);
if (status >= EntryStatus.Available)
{
result.overrideTitleText = entry.GetDisplayName(userProfile);
result.titleColor = entry.color;
if (unlockableDef != null)
{
result.overrideBodyText = unlockableDef.getUnlockedString();
}
result.bodyToken = "";
result.bodyColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.Unlockable);
}
else
{
result.titleToken = "UNIDENTIFIED";
result.titleColor = Color.gray;
result.bodyToken = "";
switch (status)
{
case EntryStatus.Unimplemented:
result.titleToken = "TOOLTIP_WIP_CONTENT_NAME";
result.bodyToken = "TOOLTIP_WIP_CONTENT_DESCRIPTION";
break;
case EntryStatus.Unencountered:
result.overrideBodyText = Language.GetString("LOGBOOK_UNLOCK_ITEM_LOG");
break;
case EntryStatus.Locked:
result.overrideBodyText = unlockableDef.getHowToUnlockString();
break;
}
result.bodyColor = Color.white;
}
return result;
}
private static TooltipContent GetMonsterTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
TooltipContent result = default(TooltipContent);
result.titleColor = entry.color;
if (status >= EntryStatus.Available)
{
result.overrideTitleText = entry.GetDisplayName(userProfile);
result.titleColor = entry.color;
result.bodyToken = "";
}
else
{
result.titleToken = "UNIDENTIFIED";
result.titleColor = Color.gray;
result.bodyToken = "LOGBOOK_UNLOCK_ITEM_MONSTER";
}
return result;
}
private static TooltipContent GetStageTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
TooltipContent result = default(TooltipContent);
result.titleColor = entry.color;
if (status >= EntryStatus.Available)
{
result.overrideTitleText = entry.GetDisplayName(userProfile);
result.titleColor = entry.color;
result.bodyToken = "";
}
else
{
result.titleToken = "UNIDENTIFIED";
result.titleColor = Color.gray;
result.bodyToken = "LOGBOOK_UNLOCK_ITEM_STAGE";
}
return result;
}
private static TooltipContent GetSurvivorTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
TooltipContent result = default(TooltipContent);
UnlockableDef unlockableDef = SurvivorCatalog.FindSurvivorDefFromBody(((CharacterBody)entry.extraData).gameObject).unlockableDef;
if (status >= EntryStatus.Available)
{
result.overrideTitleText = entry.GetDisplayName(userProfile);
result.titleColor = entry.color;
result.bodyToken = "";
}
else
{
result.titleToken = "UNIDENTIFIED";
result.bodyToken = "";
result.titleColor = Color.gray;
switch (status)
{
case EntryStatus.Unencountered:
result.overrideBodyText = Language.GetString("LOGBOOK_UNLOCK_ITEM_SURVIVOR");
break;
case EntryStatus.Locked:
result.overrideBodyText = unlockableDef.getHowToUnlockString();
break;
}
}
return result;
}
private static TooltipContent GetAchievementTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
TooltipContent result = default(TooltipContent);
UnlockableDef unlockableDef = UnlockableCatalog.GetUnlockableDef(((AchievementDef)entry.extraData).unlockableRewardIdentifier);
result.titleColor = entry.color;
result.bodyToken = "";
if (unlockableDef == null)
{
result.overrideTitleText = entry.GetDisplayName(userProfile);
result.titleColor = Color.gray;
result.overrideBodyText = "ACHIEVEMENT HAS NO UNLOCKABLE DEFINED";
result.bodyColor = Color.white;
return result;
}
if (status >= EntryStatus.Available)
{
result.titleToken = entry.GetDisplayName(userProfile);
result.titleColor = entry.color;
result.overrideBodyText = unlockableDef.getUnlockedString();
}
else
{
result.titleToken = "UNIDENTIFIED";
result.titleColor = Color.gray;
if (status == EntryStatus.Locked)
{
result.overrideBodyText = Language.GetString("UNIDENTIFIED_DESCRIPTION");
}
else
{
result.overrideBodyText = unlockableDef.getHowToUnlockString();
}
}
return result;
}
private static TooltipContent GetWIPTooltipContent(in Entry entry, UserProfile userProfile, EntryStatus status)
{
TooltipContent result = default(TooltipContent);
result.titleColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.WIP);
result.titleToken = "TOOLTIP_WIP_CONTENT_NAME";
result.bodyToken = "TOOLTIP_WIP_CONTENT_DESCRIPTION";
return result;
}
private static EntryStatus GetAlwaysAvailable(UserProfile userProfile, Entry entry)
{
return EntryStatus.Available;
}
private static EntryStatus GetUnimplemented(in Entry entry, UserProfile viewerProfile)
{
return EntryStatus.Unimplemented;
}
private static EntryStatus GetStageStatus(in Entry entry, UserProfile viewerProfile)
{
UnlockableDef unlockableLogFromBaseSceneName = SceneCatalog.GetUnlockableLogFromBaseSceneName((entry.extraData as SceneDef).baseSceneName);
if (unlockableLogFromBaseSceneName != null && viewerProfile.HasUnlockable(unlockableLogFromBaseSceneName))
{
return EntryStatus.Available;
}
return EntryStatus.Unencountered;
}
private static EntryStatus GetMonsterStatus(in Entry entry, UserProfile viewerProfile)
{
CharacterBody characterBody = (CharacterBody)entry.extraData;
UnlockableDef unlockableDef = characterBody.GetComponent<DeathRewards>()?.logUnlockableDef;
if (!unlockableDef)
{
return EntryStatus.None;
}
if (viewerProfile.HasUnlockable(unlockableDef))
{
return EntryStatus.Available;
}
if (viewerProfile.statSheet.GetStatValueULong(PerBodyStatDef.killsAgainst, characterBody.gameObject.name) != 0)
{
return EntryStatus.Unencountered;
}
return EntryStatus.Locked;
}
private static EntryStatus GetSurvivorStatus(in Entry entry, UserProfile viewerProfile)
{
CharacterBody characterBody = (CharacterBody)entry.extraData;
SurvivorDef survivorDef = SurvivorCatalog.FindSurvivorDefFromBody(characterBody.gameObject);
if (!viewerProfile.HasUnlockable(survivorDef.unlockableDef))
{
return EntryStatus.Locked;
}
if (viewerProfile.statSheet.GetStatValueULong(PerBodyStatDef.totalWins, characterBody.gameObject.name) == 0L)
{
return EntryStatus.Unencountered;
}
return EntryStatus.Available;
}
private static EntryStatus GetAchievementStatus(in Entry entry, UserProfile viewerProfile)
{
string identifier = ((AchievementDef)entry.extraData).identifier;
bool flag = viewerProfile.HasAchievement(identifier);
if (!viewerProfile.CanSeeAchievement(identifier))
{
return EntryStatus.Locked;
}
if (!flag)
{
return EntryStatus.Unencountered;
}
return EntryStatus.Available;
}
private static void BuildStaticData()
{
RoR2Application.instance.StartCoroutine(WaitForBuildingStaticData());
}
static LogBookController()
{
categories = Array.Empty<CategoryDef>();
availability = default(ResourceAvailability);
IsInitialized = false;
IsStaticDataReady = false;
lastBuiltEntitlements = null;
}
private NavigationPageInfo[] GetCategoryPages(int categoryIndex)
{
if (navigationPagesByCategory.GetLength(0) <= categoryIndex)
{
return new NavigationPageInfo[0];
}
return navigationPagesByCategory[categoryIndex];
}
public void OnLeftButton()
{
desiredPageIndex--;
}
public void OnRightButton()
{
desiredPageIndex++;
}
private void OnCategoryClicked(int categoryIndex)
{
desiredCategoryIndex = categoryIndex;
goToEndOfNextCategory = false;
}
public void OnCategoryLeftButton()
{
desiredCategoryIndex--;
goToEndOfNextCategory = false;
}
public void OnCategoryRightButton()
{
desiredCategoryIndex++;
goToEndOfNextCategory = false;
}
private void GeneratePages(UserProfile viewerProfile)
{
if (!IsInitialized)
{
Init();
}
navigationPagesByCategory = new NavigationPageInfo[categories.Length][];
IEnumerable<NavigationPageInfo> enumerable = Array.Empty<NavigationPageInfo>();
int num = 0;
for (int i = 0; i < categories.Length; i++)
{
CategoryDef categoryDef = categories[i];
Entry[] array = categoryDef.BuildEntries(viewerProfile);
bool fullWidth = categoryDef.fullWidth;
Vector2 size = entryPageContainer.rect.size;
if (fullWidth)
{
categoryDef.iconSize.x = size.x;
}
int num2 = Mathf.FloorToInt(Mathf.Max(size.x / categoryDef.iconSize.x, 1f));
int num3 = Mathf.FloorToInt(Mathf.Max(size.y / categoryDef.iconSize.y, 1f));
int num4 = num2 * num3;
int num5 = Mathf.CeilToInt((float)array.Length / (float)num4);
if (num5 <= 0)
{
num5 = 1;
}
NavigationPageInfo[] array2 = new NavigationPageInfo[num5];
for (int j = 0; j < num5; j++)
{
int num6 = j * num4;
int num7 = array.Length - num6;
int num8 = num4;
if (num8 > num7)
{
num8 = num7;
}
Entry[] array3 = new Entry[num4];
Array.Copy(array, num6, array3, 0, num8);
NavigationPageInfo navigationPageInfo = new NavigationPageInfo();
navigationPageInfo.categoryDef = categoryDef;
navigationPageInfo.entries = array3;
navigationPageInfo.index = num++;
navigationPageInfo.indexInCategory = j;
array2[j] = navigationPageInfo;
}
navigationPagesByCategory[i] = array2;
enumerable = enumerable.Concat(array2);
}
allNavigationPages = enumerable.ToArray();
}
private void Update()
{
if (desiredPageIndex > availableNavigationPages.Length - 1)
{
desiredPageIndex = availableNavigationPages.Length - 1;
desiredCategoryIndex++;
goToEndOfNextCategory = false;
}
if (desiredPageIndex < 0)
{
desiredCategoryIndex--;
desiredPageIndex = 0;
goToEndOfNextCategory = true;
}
if (desiredCategoryIndex > categories.Length - 1)
{
desiredCategoryIndex = 0;
goToEndOfNextCategory = false;
}
if (desiredCategoryIndex < 0)
{
desiredCategoryIndex = categories.Length - 1;
goToEndOfNextCategory = true;
}
foreach (MPButton element in navigationPageIndicatorAllocator.elements)
{
ColorBlock colors = element.colors;
colors.colorMultiplier = 1f;
element.colors = colors;
}
if (currentPageIndex < navigationPageIndicatorAllocator.elements.Count)
{
MPButton mPButton = navigationPageIndicatorAllocator.elements[currentPageIndex];
ColorBlock colors2 = mPButton.colors;
colors2.colorMultiplier = 2f;
mPButton.colors = colors2;
}
if (desiredCategoryIndex != currentCategoryIndex)
{
if (stateMachine.state is Idle)
{
int num = ((desiredCategoryIndex > currentCategoryIndex) ? 1 : (-1));
stateMachine.SetNextState(new ChangeCategoryState
{
newCategoryIndex = currentCategoryIndex + num,
goToLastPage = goToEndOfNextCategory
});
}
}
else if (desiredPageIndex != currentPageIndex && stateMachine.state is Idle)
{
int num2 = ((desiredPageIndex > currentPageIndex) ? 1 : (-1));
stateMachine.SetNextState(new ChangeEntriesPageState
{
newNavigationPageInfo = GetCategoryPages(currentCategoryIndex)[currentPageIndex + num2],
moveDirection = new Vector2(num2, 0f)
});
}
}
private UserProfile LookUpUserProfile()
{
return LocalUserManager.readOnlyLocalUsersList.FirstOrDefault((LocalUser v) => v != null)?.userProfile;
}
private GameObject BuildEntriesPage(NavigationPageInfo navigationPageInfo)
{
Entry[] entries = navigationPageInfo.entries;
CategoryDef categoryDef = navigationPageInfo.categoryDef;
GameObject gameObject = UnityEngine.Object.Instantiate(entryPagePrefab, entryPageContainer);
GridLayoutGroup component = gameObject.GetComponent<GridLayoutGroup>();
component.cellSize = categoryDef.iconSize;
component.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
float num = entryPageContainer.rect.width - (float)component.padding.left - (float)component.padding.right;
component.constraintCount = (int)(num / (component.cellSize.x + component.spacing.x));
UIElementAllocator<RectTransform> uIElementAllocator = new UIElementAllocator<RectTransform>((RectTransform)gameObject.transform, categoryDef.iconPrefab);
uIElementAllocator.AllocateElements(entries.Length);
UserProfile userProfile = LookUpUserProfile();
ReadOnlyCollection<RectTransform> elements = uIElementAllocator.elements;
for (int i = 0; i < elements.Count; i++)
{
RectTransform rectTransform = elements[i];
HGButton component2 = rectTransform.GetComponent<HGButton>();
Entry entry = ((i < entries.Length) ? entries[i] : null);
EntryStatus entryStatus = entry?.GetStatus(userProfile) ?? EntryStatus.None;
if (entryStatus != 0)
{
TooltipContent tooltipContent = entry.GetTooltipContent(userProfile, entryStatus);
categoryDef.initializeElementGraphics?.Invoke(rectTransform.gameObject, entry, entryStatus, userProfile);
if ((bool)component2)
{
UnityEngine.UI.Navigation navigation = component2.navigation;
navigation.mode = UnityEngine.UI.Navigation.Mode.Explicit;
int index = (i + elements.Count - 1) % elements.Count;
navigation.selectOnLeft = elements[index].GetComponent<HGButton>();
int index2 = (i + elements.Count + 1) % elements.Count;
navigation.selectOnRight = elements[index2].GetComponent<HGButton>();
if (i - component.constraintCount >= 0)
{
navigation.selectOnUp = elements[i - component.constraintCount].GetComponent<HGButton>();
}
if (i + component.constraintCount < elements.Count)
{
navigation.selectOnDown = elements[i + component.constraintCount].GetComponent<HGButton>();
}
component2.navigation = navigation;
bool flag = entryStatus >= EntryStatus.Available;
component2.interactable = true;
component2.disableGamepadClick = component2.disableGamepadClick || !flag;
component2.disablePointerClick = component2.disablePointerClick || !flag;
component2.imageOnInteractable = (flag ? component2.imageOnInteractable : null);
component2.requiredTopLayer = uiLayerKey;
component2.updateTextOnHover = true;
component2.hoverLanguageTextMeshController = hoverLanguageTextMeshController;
string titleText = tooltipContent.GetTitleText();
string bodyText = tooltipContent.GetBodyText();
Color titleColor = tooltipContent.titleColor;
titleColor.a = 0.2f;
component2.hoverToken = Language.GetStringFormatted("LOGBOOK_HOVER_DESCRIPTION_FORMAT", titleText, bodyText, ColorUtility.ToHtmlStringRGBA(titleColor));
}
if (entry.viewableNode != null)
{
ViewableTag viewableTag = rectTransform.gameObject.GetComponent<ViewableTag>();
if (!viewableTag)
{
viewableTag = rectTransform.gameObject.AddComponent<ViewableTag>();
viewableTag.viewableVisualStyle = ViewableTag.ViewableVisualStyle.Icon;
}
viewableTag.viewableName = entry.viewableNode.fullName;
}
}
if (entryStatus >= EntryStatus.Available && (bool)component2)
{
component2.onClick.AddListener(delegate
{
ViewEntry(entry);
});
}
if (entryStatus == EntryStatus.None)
{
if ((bool)component2)
{
component2.enabled = false;
component2.targetGraphic.color = spaceFillerColor;
}
else
{
rectTransform.GetComponent<Image>().color = spaceFillerColor;
}
for (int num2 = rectTransform.childCount - 1; num2 >= 0; num2--)
{
UnityEngine.Object.Destroy(rectTransform.GetChild(num2).gameObject);
}
}
if ((bool)component2 && i == 0)
{
component2.defaultFallbackButton = true;
}
}
gameObject.gameObject.SetActive(value: true);
GridLayoutGroup gridLayoutGroup = gameObject.GetComponent<GridLayoutGroup>();
Action destroyLayoutGroup = null;
int frameTimer = 2;
destroyLayoutGroup = delegate
{
int num3 = frameTimer - 1;
frameTimer = num3;
if (frameTimer <= 0)
{
gridLayoutGroup.enabled = false;
RoR2Application.onLateUpdate -= destroyLayoutGroup;
}
};
RoR2Application.onLateUpdate += destroyLayoutGroup;
return gameObject;
}
private void ViewEntry(Entry entry)
{
OnViewEntry.Invoke();
LogBookPage component = pageViewerPanel.GetComponent<LogBookPage>();
component.SetEntry(LookUpUserProfile(), entry);
component.modelPanel.SetAnglesForCharacterThumbnailForSeconds(0.5f);
ViewableTrigger.TriggerView(entry.viewableNode?.fullName);
}
private void ReturnToNavigation()
{
navigationPanel.SetActive(value: true);
pageViewerPanel.SetActive(value: false);
}
private static bool UnlockableExists(UnlockableDef unlockableDef)
{
return unlockableDef;
}
private static bool IsEntryBodyWithoutLore(in Entry entry)
{
CharacterBody obj = (CharacterBody)entry.extraData;
bool flag = false;
string text = "";
string baseNameToken = obj.baseNameToken;
if (!string.IsNullOrEmpty(baseNameToken))
{
text = baseNameToken.Replace("_NAME", "_LORE");
if (Language.english.TokenIsRegistered(text))
{
flag = true;
}
}
return !flag;
}
private static bool IsEntryPickupItemWithoutLore(in Entry entry)
{
ItemDef itemDef = ItemCatalog.GetItemDef(PickupCatalog.GetPickupDef((PickupIndex)entry.extraData).itemIndex);
return !Language.english.TokenIsRegistered(itemDef.loreToken);
}
private static bool IsEntryPickupEquipmentWithoutLore(in Entry entry)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(PickupCatalog.GetPickupDef((PickupIndex)entry.extraData).equipmentIndex);
return !Language.english.TokenIsRegistered(equipmentDef.loreToken);
}
private static bool CanSelectItemEntry(ItemDef itemDef, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if (itemDef != null)
{
ItemTierDef itemTierDef = ItemTierCatalog.GetItemTierDef(itemDef.tier);
if ((bool)itemTierDef && itemTierDef.isDroppable)
{
if (!(itemDef.requiredExpansion == null) && expansionAvailability.ContainsKey(itemDef.requiredExpansion))
{
return expansionAvailability[itemDef.requiredExpansion];
}
return true;
}
return false;
}
return false;
}
private static bool CanSelectEquipmentEntry(EquipmentDef equipmentDef, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if (equipmentDef != null)
{
if (equipmentDef.canDrop)
{
if (!(equipmentDef.requiredExpansion == null) && expansionAvailability.ContainsKey(equipmentDef.requiredExpansion))
{
return expansionAvailability[equipmentDef.requiredExpansion];
}
return true;
}
return false;
}
return false;
}
private static Entry[] BuildPickupEntries(Dictionary<ExpansionDef, bool> expansionAvailability)
{
new Entry
{
nameToken = "TOOLTIP_WIP_CONTENT_NAME",
color = Color.white,
iconTexture = LegacyResourcesAPI.Load<Texture>("Textures/MiscIcons/texWIPIcon"),
getStatusImplementation = GetUnimplemented,
getTooltipContentImplementation = GetWIPTooltipContent
};
IEnumerable<Entry> first = from pickupDef in PickupCatalog.allPickups
select ItemCatalog.GetItemDef(pickupDef.itemIndex) into itemDef
where CanSelectItemEntry(itemDef, expansionAvailability)
orderby (int)(itemDef.tier + ((itemDef.tier == ItemTier.Lunar) ? 100 : 0))
select new Entry
{
nameToken = itemDef.nameToken,
color = ColorCatalog.GetColor(itemDef.darkColorIndex),
iconTexture = itemDef.pickupIconTexture,
bgTexture = itemDef.bgIconTexture,
extraData = PickupCatalog.FindPickupIndex(itemDef.itemIndex),
modelPrefab = itemDef.pickupModelPrefab,
getStatusImplementation = GetPickupStatus,
getTooltipContentImplementation = GetPickupTooltipContent,
pageBuilderMethod = PageBuilder.SimplePickup,
isWIPImplementation = IsEntryPickupItemWithoutLore
};
IEnumerable<Entry> second = from pickupDef in PickupCatalog.allPickups
select EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex) into equipmentDef
where CanSelectEquipmentEntry(equipmentDef, expansionAvailability)
orderby !equipmentDef.isLunar
select new Entry
{
nameToken = equipmentDef.nameToken,
color = ColorCatalog.GetColor(equipmentDef.colorIndex),
iconTexture = equipmentDef.pickupIconTexture,
bgTexture = equipmentDef.bgIconTexture,
extraData = PickupCatalog.FindPickupIndex(equipmentDef.equipmentIndex),
modelPrefab = equipmentDef.pickupModelPrefab,
getStatusImplementation = GetPickupStatus,
getTooltipContentImplementation = GetPickupTooltipContent,
pageBuilderMethod = PageBuilder.SimplePickup,
isWIPImplementation = IsEntryPickupEquipmentWithoutLore
};
return first.Concat(second).ToArray();
}
private static bool CanSelectMonsterEntry(CharacterBody characterBody, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if ((bool)characterBody)
{
ExpansionRequirementComponent component = characterBody.GetComponent<ExpansionRequirementComponent>();
if (!component || !component.requiredExpansion || !expansionAvailability.ContainsKey(component.requiredExpansion) || expansionAvailability[component.requiredExpansion])
{
return UnlockableExists(characterBody.GetComponent<DeathRewards>()?.logUnlockableDef);
}
return false;
}
return false;
}
private static Entry[] BuildMonsterEntries(Dictionary<ExpansionDef, bool> expansionAvailability)
{
Entry[] array = (from characterBody in BodyCatalog.allBodyPrefabBodyBodyComponents
where CanSelectMonsterEntry(characterBody, expansionAvailability)
orderby characterBody.baseMaxHealth
select new Entry
{
nameToken = characterBody.baseNameToken,
color = ColorCatalog.GetColor(ColorCatalog.ColorIndex.HardDifficulty),
iconTexture = characterBody.portraitIcon,
extraData = characterBody,
modelPrefab = characterBody.GetComponent<ModelLocator>()?.modelTransform?.gameObject,
getStatusImplementation = GetMonsterStatus,
getTooltipContentImplementation = GetMonsterTooltipContent,
pageBuilderMethod = PageBuilder.MonsterBody,
bgTexture = (characterBody.isChampion ? LegacyResourcesAPI.Load<Texture>("Textures/ItemIcons/BG/texTier3BGIcon") : LegacyResourcesAPI.Load<Texture>("Textures/ItemIcons/BG/texTier1BGIcon")),
isWIPImplementation = IsEntryBodyWithoutLore
}).ToArray();
Dictionary<string, Entry> dictionary = new Dictionary<string, Entry>();
Entry[] array2 = array;
foreach (Entry entry in array2)
{
if (!dictionary.ContainsKey(entry.nameToken))
{
dictionary.Add(entry.nameToken, entry);
}
}
return dictionary.Values.ToArray();
}
private static bool CanSelectStageEntry(SceneDef sceneDef, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if ((bool)sceneDef)
{
ExpansionDef requiredExpansion = sceneDef.requiredExpansion;
if (!requiredExpansion || !expansionAvailability.ContainsKey(requiredExpansion) || expansionAvailability[requiredExpansion])
{
return sceneDef.shouldIncludeInLogbook;
}
return false;
}
return false;
}
private static Entry[] BuildStageEntries(Dictionary<ExpansionDef, bool> expansionAvailability)
{
return (from sceneDef in SceneCatalog.allSceneDefs
where CanSelectStageEntry(sceneDef, expansionAvailability)
orderby sceneDef.stageOrder
select new Entry
{
nameToken = sceneDef.nameToken,
iconTexture = sceneDef.previewTexture,
color = ColorCatalog.GetColor(ColorCatalog.ColorIndex.Tier2ItemDark),
getStatusImplementation = GetStageStatus,
modelPrefab = sceneDef.dioramaPrefab,
getTooltipContentImplementation = GetStageTooltipContent,
pageBuilderMethod = PageBuilder.Stage,
extraData = sceneDef,
isWIPImplementation = delegate(in Entry entry)
{
return !Language.english.TokenIsRegistered(((SceneDef)entry.extraData).loreToken);
}
}).ToArray();
}
private static bool CanSelectSurvivorBodyEntry(CharacterBody body, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if ((bool)body)
{
ExpansionRequirementComponent component = body.GetComponent<ExpansionRequirementComponent>();
if ((bool)component && (bool)component.requiredExpansion && expansionAvailability.ContainsKey(component.requiredExpansion))
{
return expansionAvailability[component.requiredExpansion];
}
return true;
}
return false;
}
private static Entry[] BuildSurvivorEntries(Dictionary<ExpansionDef, bool> expansionAvailability)
{
return (from survivorDef in SurvivorCatalog.orderedSurvivorDefs
select BodyCatalog.GetBodyPrefabBodyComponent(SurvivorCatalog.GetBodyIndexFromSurvivorIndex(survivorDef.survivorIndex)) into body
where CanSelectSurvivorBodyEntry(body, expansionAvailability)
select body into characterBody
select new Entry
{
nameToken = characterBody.baseNameToken,
color = ColorCatalog.GetColor(ColorCatalog.ColorIndex.NormalDifficulty),
iconTexture = characterBody.portraitIcon,
bgTexture = LegacyResourcesAPI.Load<Texture>("Textures/ItemIcons/BG/texSurvivorBGIcon"),
extraData = characterBody,
modelPrefab = characterBody.GetComponent<ModelLocator>()?.modelTransform?.gameObject,
getStatusImplementation = GetSurvivorStatus,
getTooltipContentImplementation = GetSurvivorTooltipContent,
pageBuilderMethod = PageBuilder.SurvivorBody,
isWIPImplementation = IsEntryBodyWithoutLore
}).ToArray();
}
private static bool CanSelectAchievementEntry(AchievementDef achievementDef, Dictionary<ExpansionDef, bool> expansionAvailability)
{
if (achievementDef != null)
{
ExpansionDef expansionDefForUnlockable = UnlockableCatalog.GetExpansionDefForUnlockable(UnlockableCatalog.GetUnlockableDef(achievementDef.unlockableRewardIdentifier)?.index ?? UnlockableIndex.None);
if ((bool)expansionDefForUnlockable && expansionAvailability.ContainsKey(expansionDefForUnlockable))
{
return expansionAvailability[expansionDefForUnlockable];
}
return true;
}
return false;
}
private static Entry[] BuildAchievementEntries(Dictionary<ExpansionDef, bool> expansionAvailability)
{
return (from achievementDef in AchievementManager.allAchievementDefs
where CanSelectAchievementEntry(achievementDef, expansionAvailability)
select new Entry
{
nameToken = achievementDef.nameToken,
color = ColorCatalog.GetColor(ColorCatalog.ColorIndex.NormalDifficulty),
iconTexture = achievementDef.GetAchievedIcon()?.texture,
extraData = achievementDef,
modelPrefab = null,
getStatusImplementation = GetAchievementStatus,
getTooltipContentImplementation = GetAchievementTooltipContent
}).ToArray();
}
private static Entry[] BuildProfileEntries(UserProfile viewerProfile)
{
List<Entry> entries = new List<Entry>();
if (true)
{
foreach (string availableProfileName in PlatformSystems.saveSystem.GetAvailableProfileNames())
{
AddProfileStatsEntry(PlatformSystems.saveSystem.GetProfile(availableProfileName));
}
}
else if (viewerProfile != null)
{
AddProfileStatsEntry(viewerProfile);
}
return entries.ToArray();
void AddProfileStatsEntry(UserProfile userProfile)
{
Entry item = new Entry
{
pageBuilderMethod = PageBuilder.StatsPanel,
getStatusImplementation = delegate
{
return EntryStatus.Available;
},
extraData = userProfile,
getDisplayNameImplementation = delegate(in Entry entry, UserProfile _viewerProfile)
{
return ((UserProfile)entry.extraData).name;
},
iconTexture = userProfile.portraitTexture
};
entries.Add(item);
}
}
private static Entry[] BuildMorgueEntries(UserProfile viewerProfile)
{
List<Entry> entries = CollectionPool<Entry, List<Entry>>.RentCollection();
List<RunReport> list = CollectionPool<RunReport, List<RunReport>>.RentCollection();
MorgueManager.LoadHistoryRunReports(list);
foreach (RunReport item2 in list)
{
AddRunReportEntry(item2);
}
CollectionPool<RunReport, List<RunReport>>.ReturnCollection(list);
Entry[] result = entries.ToArray();
CollectionPool<Entry, List<Entry>>.ReturnCollection(entries);
return result;
void AddRunReportEntry(RunReport runReport)
{
GetPrimaryPlayerInfo(runReport, out var _, out var primaryPlayerBody3);
Entry item = new Entry
{
pageBuilderMethod = PageBuilder.RunReportPanel,
getStatusImplementation = GetEntryStatus,
extraData = runReport,
getDisplayNameImplementation = GetDisplayName,
getTooltipContentImplementation = GetTooltipContent,
iconTexture = primaryPlayerBody3?.portraitIcon
};
entries.Add(item);
}
static string GetDisplayName(in Entry entry, UserProfile _viewerProfile)
{
return ((RunReport)entry.extraData).snapshotTimeUtc.ToLocalTime().ToString("G", CultureInfo.CurrentCulture);
}
static EntryStatus GetEntryStatus(in Entry entry, UserProfile _viewerProfile)
{
return EntryStatus.Available;
}
void GetPrimaryPlayerInfo(RunReport _runReport, out RunReport.PlayerInfo primaryPlayerInfo, out CharacterBody primaryPlayerBody)
{
primaryPlayerInfo = _runReport.FindPlayerInfo(viewerProfile) ?? _runReport.FindFirstPlayerInfo();
primaryPlayerBody = BodyCatalog.GetBodyPrefabBodyComponent(primaryPlayerInfo?.bodyIndex ?? BodyIndex.None);
}
TooltipContent GetTooltipContent(in Entry entry, UserProfile _viewerProfile, EntryStatus entryStatus)
{
RunReport runReport2 = (RunReport)entry.extraData;
GetPrimaryPlayerInfo(runReport2, out var _, out var primaryPlayerBody2);
TooltipContent result2 = default(TooltipContent);
result2.overrideTitleText = Language.GetStringFormatted("LOGBOOK_ENTRY_RUNREPORT_TOOLTIP_TITLE_FORMAT", runReport2.snapshotTimeUtc.ToLocalTime().ToString("G", CultureInfo.CurrentCulture));
result2.overrideBodyText = Language.GetStringFormatted("LOGBOOK_ENTRY_RUNREPORT_TOOLTIP_BODY_FORMAT", Language.GetString(primaryPlayerBody2?.baseNameToken ?? string.Empty), Language.GetString(runReport2.gameMode?.nameToken ?? string.Empty), Language.GetString(runReport2.gameEnding?.endingTextToken ?? string.Empty));
return result2;
}
}
private static IEnumerator WaitForBuildingStaticData()
{
IsStaticDataReady = false;
Dictionary<ExpansionDef, bool> expansionAvailability = new Dictionary<ExpansionDef, bool>();
List<EntitlementDef> list = new List<EntitlementDef>();
foreach (ExpansionDef expansionDef in ExpansionCatalog.expansionDefs)
{
expansionAvailability.Add(expansionDef, !expansionDef.requiredEntitlement || EntitlementManager.localUserEntitlementTracker.AnyUserHasEntitlement(expansionDef.requiredEntitlement));
if (expansionAvailability[expansionDef])
{
list.Add(expansionDef.requiredEntitlement);
}
}
if (lastBuiltEntitlements != null && lastBuiltEntitlements.SequenceEqual(list))
{
lastBuiltEntitlements = list;
IsStaticDataReady = true;
yield break;
}
lastBuiltEntitlements = list;
yield return null;
Entry[] pickupEntries = BuildPickupEntries(expansionAvailability);
yield return null;
Entry[] monsterEntries = BuildMonsterEntries(expansionAvailability);
yield return null;
Entry[] stageEntries = BuildStageEntries(expansionAvailability);
yield return null;
Entry[] survivorEntries = BuildSurvivorEntries(expansionAvailability);
yield return null;
Entry[] achievementEntries = BuildAchievementEntries(expansionAvailability);
yield return null;
categories = new CategoryDef[7]
{
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_ITEMANDEQUIPMENT",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/ItemEntryIcon"),
buildEntries = (UserProfile viewerProfile) => pickupEntries,
navButtons = new CategoryDef.NavButtons
{
navigate = "LOGBOOK_ZOOMINOUT"
}
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_MONSTER",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/MonsterEntryIcon"),
buildEntries = (UserProfile viewerProfile) => monsterEntries,
navButtons = new CategoryDef.NavButtons
{
navigate = "LOGBOOK_ZOOMINOUT"
}
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_STAGE",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/StageEntryIcon"),
buildEntries = (UserProfile viewerProfile) => stageEntries
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_SURVIVOR",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/SurvivorEntryIcon"),
buildEntries = (UserProfile viewerProfile) => survivorEntries
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_ACHIEVEMENTS",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/AchievementEntryIcon"),
buildEntries = (UserProfile viewerProfile) => achievementEntries,
initializeElementGraphics = CategoryDef.InitializeChallenge
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_STATS",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/StatsEntryIcon"),
buildEntries = BuildProfileEntries,
initializeElementGraphics = CategoryDef.InitializeStats,
navButtons = new CategoryDef.NavButtons
{
scroll = "",
rotate = "LOGBOOK_PAN"
}
},
new CategoryDef
{
nameToken = "LOGBOOK_CATEGORY_MORGUE",
iconPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/Logbook/MorgueEntryIcon"),
buildEntries = BuildMorgueEntries,
initializeElementGraphics = CategoryDef.InitializeMorgue,
navButtons = new CategoryDef.NavButtons
{
rotate = "",
navigate = ""
}
}
};
RegisterViewables(categories);
availability.MakeAvailable();
IsStaticDataReady = true;
EntitlementManager.UpdateLocalUsersEntitlements();
}
[ConCommand(commandName = "logbook_list_unfinished_lore", flags = ConVarFlags.None, helpText = "Prints all logbook entries which still have undefined lore.")]
private static void CCLogbookListUnfinishedLore(ConCommandArgs args)
{
List<string> list = new List<string>();
CategoryDef[] array = categories;
for (int i = 0; i < array.Length; i++)
{
Entry[] array2 = array[i].BuildEntries(args.GetSenderLocalUser()?.userProfile);
foreach (Entry entry in array2)
{
string text = "";
if (entry.extraData is UnityEngine.Object @object)
{
text = @object.name;
}
if (entry.isWip)
{
list.Add(entry.extraData?.GetType()?.Name + " \"" + text + "\" \"" + Language.GetString(entry.nameToken) + "\"");
}
}
}
args.Log(string.Join("\n", list));
}
private static void RegisterViewables(CategoryDef[] categoriesToGenerateFrom)
{
ViewablesCatalog.Node node = new ViewablesCatalog.Node("Logbook", isFolder: true);
CategoryDef[] array = categories;
foreach (CategoryDef obj in array)
{
ViewablesCatalog.Node parent = (obj.viewableNode = new ViewablesCatalog.Node(obj.nameToken, isFolder: true, node));
Entry[] array2 = obj.BuildEntries(null);
foreach (Entry entry in array2)
{
string nameToken = entry.nameToken;
ViewablesCatalog.Node entryNode;
AchievementDef achievementDef;
bool hasPrereq;
if (!entry.isWip && !(nameToken == "TOOLTIP_WIP_CONTENT_NAME") && !string.IsNullOrEmpty(nameToken))
{
entryNode = new ViewablesCatalog.Node(nameToken, isFolder: false, parent);
object extraData = entry.extraData;
achievementDef = extraData as AchievementDef;
if (achievementDef != null)
{
hasPrereq = !string.IsNullOrEmpty(achievementDef.prerequisiteAchievementIdentifier);
entryNode.shouldShowUnviewed = Check;
}
else
{
entryNode.shouldShowUnviewed = Check;
}
entry.viewableNode = entryNode;
}
bool Check(UserProfile userProfile)
{
if (userProfile.HasViewedViewable(entryNode.fullName))
{
return false;
}
if (userProfile.HasAchievement(achievementDef.identifier))
{
return false;
}
if (hasPrereq)
{
return userProfile.HasAchievement(achievementDef.prerequisiteAchievementIdentifier);
}
return true;
}
bool Check(UserProfile viewerProfile)
{
if (viewerProfile.HasViewedViewable(entryNode.fullName))
{
return false;
}
return entry.GetStatus(viewerProfile) == EntryStatus.Available;
}
}
}
ViewablesCatalog.AddNodeToRoot(node);
LogBookController.OnViewablesRegistered?.Invoke();
}
}