r2mods/ilspy_dump/ror2_csproj/Assets.RoR2.Scripts.Platform/ActivityManager.cs

385 lines
12 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using RoR2;
using RoR2.EntitlementManagement;
using RoR2.UI.MainMenu;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
namespace Assets.RoR2.Scripts.Platform;
public class ActivityManager
{
protected ActivityData LoadedActivityData;
protected Dictionary<string, BaseActivity> InProgressActivities = new Dictionary<string, BaseActivity>();
protected Dictionary<string, BaseActivity> AvailableActivities = new Dictionary<string, BaseActivity>();
protected BaseActivity ActivityToProcess;
public bool IsInitialized { get; private set; }
public BaseActivity.ActivityGameMode CurrentGameMode
{
get
{
GameModeIndex gameModeIndex = GameModeIndex.Invalid;
if (null != PreGameController.instance)
{
gameModeIndex = PreGameController.instance.gameModeIndex;
}
if (null != Run.instance)
{
gameModeIndex = Run.instance.gameModeIndex;
}
if (GameModeIndex.Invalid != gameModeIndex)
{
if (gameModeIndex == GameModeCatalog.FindGameModeIndex("ClassicRun"))
{
return BaseActivity.ActivityGameMode.ClassicRun;
}
if (gameModeIndex == GameModeCatalog.FindGameModeIndex("EclipseRun"))
{
return BaseActivity.ActivityGameMode.Eclipse;
}
if (gameModeIndex == GameModeCatalog.FindGameModeIndex("InfiniteTowerRun"))
{
return BaseActivity.ActivityGameMode.InfiniteTower;
}
if (gameModeIndex == GameModeCatalog.FindGameModeIndex("WeeklyRun"))
{
return BaseActivity.ActivityGameMode.WeeklyRun;
}
}
Debug.LogError("ActivityManager::CurrentGameMode property unable to determine GameMode.");
return BaseActivity.ActivityGameMode.Any;
}
}
public BaseActivity.ActivityGameType CurrentGameType
{
get
{
ReadOnlyCollection<NetworkUser> readOnlyLocalPlayersList = NetworkUser.readOnlyLocalPlayersList;
if (readOnlyLocalPlayersList != null)
{
if (readOnlyLocalPlayersList.Count == 1)
{
return BaseActivity.ActivityGameType.SinglePlayer;
}
if (readOnlyLocalPlayersList.Count > 1)
{
return BaseActivity.ActivityGameType.MultiPlayer;
}
}
Debug.LogError("ActivityManager::CurrentGameType property unable to determine GameType.");
return BaseActivity.ActivityGameType.Any;
}
}
public BaseActivity.ActivitySurvivor CurrentSurvivor
{
get
{
UserProfile userProfile = LocalUserManager.GetFirstLocalUser()?.userProfile;
if (userProfile != null)
{
SurvivorDef survivorDef = userProfile?.GetSurvivorPreference();
if (null != survivorDef)
{
BaseActivity.ActivitySurvivor result = BaseActivity.ActivitySurvivor.Any;
if (Enum.TryParse<BaseActivity.ActivitySurvivor>(survivorDef.cachedName, out result))
{
return result;
}
}
}
Debug.LogError("ActivityManager::CurrentSurvivor property unable to determine survivor.");
return BaseActivity.ActivitySurvivor.Any;
}
}
private bool ValidCurrentSelectorExists
{
get
{
if ((null != PreGameController.instance || null != Run.instance) && LocalUserManager.GetFirstLocalUser()?.userProfile != null)
{
if (NetworkUser.readOnlyLocalPlayersList != null)
{
return NetworkUser.readOnlyLocalPlayersList.Count >= 0;
}
return false;
}
return false;
}
}
public BaseActivitySelector CurrentActivitySelector
{
get
{
if (ValidCurrentSelectorExists)
{
return new BaseActivitySelector
{
activitySurvivor = CurrentSurvivor,
activityGameMode = CurrentGameMode,
activityGameType = CurrentGameType
};
}
return null;
}
}
public virtual void Initialize()
{
MainMenuController.OnPreMainMenuInitialized -= OnPreMainMenuInitializedCallback;
MainMenuController.OnPreMainMenuInitialized += OnPreMainMenuInitializedCallback;
LocalUserManager.onUserSignIn -= OnLocalUserSignIn;
LocalUserManager.onUserSignIn += OnLocalUserSignIn;
BaseUserEntitlementTracker<LocalUser>.OnAllUserEntitlementsUpdated = (Action)Delegate.Remove(BaseUserEntitlementTracker<LocalUser>.OnAllUserEntitlementsUpdated, new Action(OnEntitlementsChangedCallback));
BaseUserEntitlementTracker<LocalUser>.OnAllUserEntitlementsUpdated = (Action)Delegate.Combine(BaseUserEntitlementTracker<LocalUser>.OnAllUserEntitlementsUpdated, new Action(OnEntitlementsChangedCallback));
Run.onRunStartGlobal += OnRunStartGlobal;
Run.onClientGameOverGlobal += OnClientGameOverGlobal;
}
protected virtual void OnPreMainMenuReInitializedCallback()
{
AbandonInProgressActivities();
}
protected virtual void OnLocalUserSignIn(LocalUser localUser)
{
if (localUser.userProfile != null && localUser.userProfile == LocalUserManager.GetFirstLocalUser().userProfile)
{
RebuildActivityAvailabilityForUser(localUser);
IsInitialized = true;
}
}
protected virtual void AbandonInProgressActivities()
{
BaseActivitySelector activitySelector = new BaseActivitySelector();
PlatformSystems.activityManager.TryToAbandonActivity(activitySelector);
}
protected virtual void OnClientGameOverGlobal(Run run, RunReport runReport)
{
if (runReport.gameEnding == RoR2Content.GameEndings.StandardLoss)
{
if (ValidCurrentSelectorExists)
{
PlatformSystems.activityManager.TryToFailActivity(PlatformSystems.activityManager.CurrentActivitySelector);
}
else
{
Debug.LogError("ActivityManager::OnClientGameOverGlobal - missing context to fail activities activities on Game Over.");
}
}
}
protected virtual void OnRunStartGlobal(Run run)
{
if (ValidCurrentSelectorExists)
{
TryToStartActivity(CurrentActivitySelector);
}
else
{
Debug.LogError("ActivityManager::OnRunStartGlobal - missing context to start activities on Run start.");
}
}
protected virtual void OnPreMainMenuInitializedCallback()
{
MainMenuController.OnPreMainMenuInitialized -= OnPreMainMenuInitializedCallback;
AsyncOperationHandle<ActivityData> handle = Addressables.LoadAssetAsync<ActivityData>("RoR2/Base/Common/ActivityData.asset");
ActivityData loadedActivityData = handle.WaitForCompletion();
LoadedActivityData = loadedActivityData;
Addressables.Release(handle);
if (GameIntentReceiver.GameIntentAdapter.hasPendingGameIntent)
{
CreateStartupActivity();
}
GameIntentReceiver.GameIntentAdapter.OnGameIntentReceivedEvent -= GameIntentReceiverListener;
GameIntentReceiver.GameIntentAdapter.OnGameIntentReceivedEvent += GameIntentReceiverListener;
if (ActivityToProcess != null)
{
RoR2Application.instance.StartCoroutine(ProcessGameActivity());
GameIntentReceiver.GameIntentAdapter.ClearPendingGameIntent();
}
MainMenuController.OnPreMainMenuInitialized += OnPreMainMenuReInitializedCallback;
}
protected virtual void CreateStartupActivity()
{
}
public virtual void GameIntentReceiverListener(GameIntentAdapter.EventResponse eventResponseObject)
{
eventResponseObject.EventHasBeenHandled(eventHandled: false);
}
public virtual void TryToStartActivity(BaseActivitySelector activitySelector)
{
}
public virtual void TryToCompleteActivity(BaseActivitySelector activitySelector, bool markUnavailableOnComplete = true, bool applyAsDelta = true)
{
}
public virtual void TryToAbandonActivity(BaseActivitySelector activitySelector)
{
}
public virtual void TryToFailActivity(BaseActivitySelector activitySelector)
{
}
public virtual void TryToSetActivityAvailability(BaseActivitySelector activitySelector, bool newAvailability, bool applyAsDelta = true, bool sendImmediate = true)
{
}
public virtual void FlushAvailabilityUpdates(bool applyAsDelta)
{
}
public virtual bool ShouldSkipGameIntentHandler(BaseActivity activity)
{
return CurrentActivitySelector?.IsCompatibleWith(activity) ?? false;
}
public virtual bool IsActivityAvailable(BaseActivity baseActivity)
{
return AvailableActivities.ContainsKey(baseActivity.ActivityID);
}
protected IEnumerator ProcessGameActivity()
{
if (!IsInitialized)
{
yield return new WaitForEndOfFrame();
}
BaseActivity gameActivity = LoadedActivityData.LookupActivityByID(ActivityToProcess.ActivityID);
if (gameActivity == null)
{
Debug.LogError("ActivityManager::ProcessGameActivity() was unable to find data for a Game Activity!");
yield break;
}
if (!IsActivityAvailable(gameActivity))
{
Debug.LogError("ActivityManager::ProcessGameActivity() user attempted to launch an unavailable activity!");
yield break;
}
if (!RoR2Application.IsMainScene)
{
if (ShouldSkipGameIntentHandler(gameActivity))
{
yield break;
}
global::RoR2.Console.instance.SubmitCmd(null, "transition_command \"disconnect\";");
yield return new WaitForSeconds(1f);
global::RoR2.Console.instance.SubmitCmd(null, "transition_command \"set_scene title\";");
while (!RoR2Application.IsMainScene)
{
yield return new WaitForEndOfFrame();
}
}
while (!RoR2Application.IsMainMenuInitialized)
{
yield return new WaitForEndOfFrame();
}
string gameModeStr;
if (gameActivity.GameMode == BaseActivity.ActivityGameMode.ClassicRun || gameActivity.GameMode == BaseActivity.ActivityGameMode.Any)
{
gameModeStr = "ClassicRun";
}
else if (gameActivity.GameMode == BaseActivity.ActivityGameMode.WeeklyRun)
{
gameModeStr = "WeeklyRun";
}
else if (gameActivity.GameMode == BaseActivity.ActivityGameMode.Eclipse)
{
gameModeStr = "EclipseRun";
}
else if (gameActivity.GameMode == BaseActivity.ActivityGameMode.InfiniteTower)
{
gameModeStr = "InfiniteTowerRun";
}
else
{
Debug.LogError("ActivityManager::ProcessGameActivity() - Trying to transition to gamemode with unhandled BaseActivity.ActivityGameMode. Transitioning to Classic Run...");
gameModeStr = "ClassicRun";
}
while (TransitionCommand.requestPending)
{
yield return new WaitForEndOfFrame();
}
global::RoR2.Console.instance.SubmitCmd(null, "transition_command \"gamemode " + gameModeStr + "; host 0;\"");
string text = gameActivity.Survivor.ToString();
if (string.Compare("Any", text) != 0)
{
SurvivorIndex survivorIndex = SurvivorCatalog.FindSurvivorIndex(text);
UserProfile userProfile = LocalUserManager.GetFirstLocalUser()?.userProfile;
if (userProfile.HasSurvivorUnlocked(survivorIndex))
{
SurvivorDef survivorDef = SurvivorCatalog.GetSurvivorDef(survivorIndex);
userProfile.SetSurvivorPreference(survivorDef);
}
}
yield return new WaitForSeconds(2f);
RoR2Application.SetMapsEnabled(enabled: true);
}
public void RebuildActivityAvailabilityForUser(LocalUser localUser)
{
if (LoadedActivityData == null)
{
return;
}
UserProfile userProfile = localUser.userProfile;
BaseActivitySelector baseActivitySelector = new BaseActivitySelector();
List<BaseActivity> list = LoadedActivityData.CompareActivityCriteria(baseActivitySelector);
foreach (BaseActivity item in list)
{
if (item.AchievementID.Length == 0)
{
continue;
}
baseActivitySelector.activityAchievementID = item.AchievementID;
bool flag = userProfile.CanSeeAchievement(item.AchievementID);
bool flag2 = userProfile.HasAchievement(item.AchievementID);
if (item.RequiredEntitlementID.Length > 0)
{
if (EntitlementCatalog.FindEntitlementIndex(item.RequiredEntitlementID) == EntitlementIndex.None)
{
Debug.LogError("ActivityManager::RebuildAvailabilityForUser - Activity requires entitlement (" + item.RequiredEntitlementID + ") that is not defined in the EntitlementCatalog. (probably a typo)");
}
else
{
EntitlementDef entitlementDef = EntitlementCatalog.GetEntitlementDef(EntitlementCatalog.FindEntitlementIndex(item.RequiredEntitlementID));
if (!EntitlementManager.localUserEntitlementTracker.UserHasEntitlement(localUser, entitlementDef))
{
flag = false;
}
}
}
TryToSetActivityAvailability(baseActivitySelector, flag && !flag2, applyAsDelta: false, sendImmediate: false);
}
if (list.Count > 0)
{
FlushAvailabilityUpdates(applyAsDelta: false);
}
}
private void OnEntitlementsChangedCallback()
{
RebuildActivityAvailabilityForUser(LocalUserManager.GetFirstLocalUser());
}
}