r2mods/ilspy_dump/ror2_csproj/RoR2/WeeklyRun.cs

451 lines
12 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.InteropServices;
using Facepunch.Steamworks;
using RoR2.ExpansionManagement;
using UnityEngine;
using UnityEngine.Networking;
namespace RoR2;
public class WeeklyRun : Run
{
private Xoroshiro128Plus bossAffixRng;
public static readonly DateTime startDate = new DateTime(2018, 8, 27, 0, 0, 0, 0, DateTimeKind.Utc);
public const int cycleLength = 3;
private string leaderboardName;
[SyncVar]
private uint serverSeedCycle;
private EquipmentIndex[] bossAffixes = Array.Empty<EquipmentIndex>();
public SpawnCard crystalSpawnCard;
public uint crystalCount = 3u;
public uint crystalRewardValue = 50u;
public uint crystalsRequiredToKill = 3u;
private List<OnDestroyCallback> crystalActiveList = new List<OnDestroyCallback>();
public SpawnCard equipmentBarrelSpawnCard;
public uint equipmentBarrelCount = 3u;
public float equipmentBarrelRadius = 10f;
public static DateTime now => Util.UnixTimeStampToDateTimeUtc(Client.Instance.Utils.GetServerRealTime());
public uint crystalsKilled => (uint)(crystalCount - crystalActiveList.Count);
public uint NetworkserverSeedCycle
{
get
{
return serverSeedCycle;
}
[param: In]
set
{
SetSyncVar(value, ref serverSeedCycle, 64u);
}
}
public static uint GetCurrentSeedCycle()
{
return (uint)((now - startDate).Days / 3);
}
public static DateTime GetSeedCycleStartDateTime(uint seedCycle)
{
return startDate.AddDays(seedCycle * 3);
}
public static DateTime GetSeedCycleStartDateTime()
{
return GetSeedCycleStartDateTime(GetCurrentSeedCycle());
}
public static DateTime GetSeedCycleEndDateTime()
{
return GetSeedCycleStartDateTime(GetCurrentSeedCycle() + 1);
}
protected new void Start()
{
base.Start();
if (NetworkServer.active)
{
bossAffixRng = new Xoroshiro128Plus(runRNG.nextUlong);
NetworkserverSeedCycle = GetCurrentSeedCycle();
}
isRunWeekly = true;
bossAffixes = new EquipmentIndex[2]
{
RoR2Content.Equipment.AffixRed.equipmentIndex,
RoR2Content.Equipment.AffixBlue.equipmentIndex
};
}
protected override void OnFixedUpdate()
{
base.OnFixedUpdate();
if (!TeleporterInteraction.instance)
{
return;
}
bool flag = crystalsRequiredToKill > crystalsKilled;
if (flag == TeleporterInteraction.instance.locked)
{
return;
}
if (flag)
{
if (NetworkServer.active)
{
TeleporterInteraction.instance.locked = true;
}
return;
}
if (NetworkServer.active)
{
TeleporterInteraction.instance.locked = false;
}
ChildLocator component = TeleporterInteraction.instance.GetComponent<ModelLocator>().modelTransform.GetComponent<ChildLocator>();
if ((bool)component)
{
Transform transform = component.FindChild("TimeCrystalBeaconBlocker");
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/TimeCrystalDeath"), new EffectData
{
origin = transform.transform.position
}, transmit: false);
transform.gameObject.SetActive(value: false);
}
}
public override ulong GenerateSeedForNewRun()
{
return (ulong)GetCurrentSeedCycle() << 32;
}
public override void HandlePlayerFirstEntryAnimation(CharacterBody body, Vector3 spawnPosition, Quaternion spawnRotation)
{
}
public override void AdvanceStage(SceneDef nextScene)
{
if (stageClearCount == 1 && SceneInfo.instance.countsAsStage)
{
BeginGameOver(RoR2Content.GameEndings.PrismaticTrialEnding);
}
else
{
base.AdvanceStage(nextScene);
}
}
public override void OnClientGameOver(RunReport runReport)
{
base.OnClientGameOver(runReport);
ClientSubmitLeaderboardScore(runReport);
}
public override void OnServerBossAdded(BossGroup bossGroup, CharacterMaster characterMaster)
{
base.OnServerBossAdded(bossGroup, characterMaster);
if (stageClearCount >= 1)
{
if (characterMaster.inventory.GetEquipmentIndex() == EquipmentIndex.None)
{
characterMaster.inventory.SetEquipmentIndex(bossAffixRng.NextElementUniform(bossAffixes));
}
characterMaster.inventory.GiveItem(RoR2Content.Items.BoostHp, 5);
characterMaster.inventory.GiveItem(RoR2Content.Items.BoostDamage);
}
}
public override void OnServerBossDefeated(BossGroup bossGroup)
{
base.OnServerBossDefeated(bossGroup);
if ((bool)TeleporterInteraction.instance)
{
TeleporterInteraction.instance.holdoutZoneController.FullyChargeHoldoutZone();
}
}
public override GameObject GetTeleportEffectPrefab(GameObject objectToTeleport)
{
return LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/TeleportOutCrystalBoom");
}
public override void OnServerTeleporterPlaced(SceneDirector sceneDirector, GameObject teleporter)
{
base.OnServerTeleporterPlaced(sceneDirector, teleporter);
DirectorPlacementRule directorPlacementRule = new DirectorPlacementRule();
directorPlacementRule.placementMode = DirectorPlacementRule.PlacementMode.Random;
for (int i = 0; i < crystalCount; i++)
{
GameObject gameObject = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(crystalSpawnCard, directorPlacementRule, stageRng));
if ((bool)gameObject)
{
DeathRewards component2 = gameObject.GetComponent<DeathRewards>();
if ((bool)component2)
{
component2.goldReward = crystalRewardValue;
}
}
crystalActiveList.Add(OnDestroyCallback.AddCallback(gameObject, delegate(OnDestroyCallback component)
{
crystalActiveList.Remove(component);
}));
}
if ((bool)TeleporterInteraction.instance)
{
ChildLocator component3 = TeleporterInteraction.instance.GetComponent<ModelLocator>().modelTransform.GetComponent<ChildLocator>();
if ((bool)component3)
{
component3.FindChild("TimeCrystalProps").gameObject.SetActive(value: true);
component3.FindChild("TimeCrystalBeaconBlocker").gameObject.SetActive(value: true);
}
}
}
public override void OnPlayerSpawnPointsPlaced(SceneDirector sceneDirector)
{
if (stageClearCount != 0)
{
return;
}
SpawnPoint spawnPoint = SpawnPoint.readOnlyInstancesList[0];
if ((bool)spawnPoint)
{
float num = 360f / (float)equipmentBarrelCount;
for (int i = 0; i < equipmentBarrelCount; i++)
{
Vector3 vector = Quaternion.AngleAxis(num * (float)i, Vector3.up) * (Vector3.forward * equipmentBarrelRadius);
DirectorPlacementRule directorPlacementRule = new DirectorPlacementRule();
directorPlacementRule.minDistance = 0f;
directorPlacementRule.maxDistance = 3f;
directorPlacementRule.placementMode = DirectorPlacementRule.PlacementMode.NearestNode;
directorPlacementRule.position = spawnPoint.transform.position + vector;
DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(equipmentBarrelSpawnCard, directorPlacementRule, stageRng));
}
}
}
public static string GetLeaderboardName(int playerCount, uint seedCycle)
{
if (Console.sessionCheatsEnabled)
{
return null;
}
return string.Format(CultureInfo.InvariantCulture, "weekly{0}p{1}", playerCount, seedCycle);
}
protected void ClientSubmitLeaderboardScore(RunReport runReport)
{
Debug.LogFormat("Attempting to submit leaderboard score.");
if (!runReport.gameEnding.isWin)
{
return;
}
bool flag = false;
foreach (NetworkUser readOnlyLocalPlayers in NetworkUser.readOnlyLocalPlayersList)
{
if (readOnlyLocalPlayers.isParticipating)
{
flag = true;
break;
}
}
if (!flag)
{
return;
}
int num = PlayerCharacterMasterController.instances.Count;
switch (num)
{
default:
return;
case 3:
case 4:
num = 4;
break;
case 1:
case 2:
break;
}
string value = GetLeaderboardName(num, serverSeedCycle);
if (string.IsNullOrEmpty(value))
{
return;
}
int[] subScores = new int[64];
GameObject bodyPrefab = BodyCatalog.GetBodyPrefab(NetworkUser.readOnlyLocalPlayersList[0].bodyIndexPreference);
if (!bodyPrefab)
{
return;
}
SurvivorDef survivorDef = SurvivorCatalog.FindSurvivorDefFromBody(bodyPrefab);
if (!(survivorDef == null))
{
subScores[1] = (int)survivorDef.survivorIndex;
Leaderboard leaderboard = Client.Instance.GetLeaderboard(value, Client.LeaderboardSortMethod.Ascending, Client.LeaderboardDisplayType.TimeMilliSeconds);
leaderboard.OnBoardInformation = delegate
{
leaderboard.AddScore(onlyIfBeatsOldScore: true, (int)Math.Ceiling((double)runReport.runStopwatchValue * 1000.0), subScores);
};
}
}
public override void OverrideRuleChoices(RuleChoiceMask mustInclude, RuleChoiceMask mustExclude, ulong runSeed)
{
base.OverrideRuleChoices(mustInclude, mustExclude, base.seed);
ForceChoice(mustInclude, mustExclude, "Difficulty.Normal");
ForceChoice(mustInclude, mustExclude, "Misc.StartingMoney.50");
ForceChoice(mustInclude, mustExclude, "Misc.StageOrder.Random");
ForceChoice(mustInclude, mustExclude, "Misc.KeepMoneyBetweenStages.Off");
for (int i = 0; i < ArtifactCatalog.artifactCount; i++)
{
ForceChoice(mustInclude, mustExclude, FindRuleForArtifact((ArtifactIndex)i).FindChoice("Off"));
}
Xoroshiro128Plus xoroshiro128Plus = new Xoroshiro128Plus(runSeed);
Debug.LogFormat("Weekly Run Seed: {0}", runSeed);
if (xoroshiro128Plus.nextNormalizedFloat < 1f)
{
int num = xoroshiro128Plus.RangeInt(2, 7);
ArtifactIndex[] array = new ArtifactIndex[ArtifactCatalog.artifactCount];
for (int j = 0; j < array.Length; j++)
{
array[j] = (ArtifactIndex)j;
}
Util.ShuffleArray(array, xoroshiro128Plus);
for (int k = 0; k < num; k++)
{
if (ArtifactCatalog.GetArtifactDef(array[k]) != RoR2Content.Artifacts.randomSurvivorOnRespawnArtifactDef)
{
ForceChoice(mustInclude, mustExclude, FindRuleForArtifact(array[k]).FindChoice("On"));
}
}
}
ItemIndex itemIndex = ItemIndex.Count;
for (ItemIndex itemCount = (ItemIndex)ItemCatalog.itemCount; itemIndex < itemCount; itemIndex++)
{
ItemDef itemDef = ItemCatalog.GetItemDef(itemIndex);
RuleChoiceDef ruleChoiceDef = RuleCatalog.FindRuleDef("Items." + itemDef.name)?.FindChoice("On");
if (ruleChoiceDef != null)
{
ForceChoice(mustInclude, mustExclude, ruleChoiceDef);
}
}
EquipmentIndex equipmentIndex = (EquipmentIndex)0;
for (EquipmentIndex equipmentCount = (EquipmentIndex)EquipmentCatalog.equipmentCount; equipmentIndex < equipmentCount; equipmentIndex++)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
RuleChoiceDef ruleChoiceDef2 = RuleCatalog.FindRuleDef("Equipment." + equipmentDef.name)?.FindChoice("On");
if (ruleChoiceDef2 != null)
{
ForceChoice(mustInclude, mustExclude, ruleChoiceDef2);
}
}
foreach (ExpansionDef expansionDef in ExpansionCatalog.expansionDefs)
{
RuleChoiceDef ruleChoiceDef3 = RuleCatalog.FindRuleDef("Expansions." + expansionDef.name)?.FindChoice("On");
if (ruleChoiceDef3 != null)
{
ForceChoice(mustInclude, mustExclude, ruleChoiceDef3);
}
}
static RuleDef FindRuleForArtifact(ArtifactIndex artifactIndex)
{
ArtifactDef artifactDef = ArtifactCatalog.GetArtifactDef(artifactIndex);
return RuleCatalog.FindRuleDef("Artifacts." + artifactDef.cachedName);
}
}
public override bool IsUnlockableUnlocked(UnlockableDef unlockableDef)
{
return true;
}
public override bool CanUnlockableBeGrantedThisRun(UnlockableDef unlockableDef)
{
return false;
}
public override bool DoesEveryoneHaveThisUnlockableUnlocked(UnlockableDef unlockableDef)
{
return true;
}
protected override void HandlePostRunDestination()
{
Console.instance.SubmitCmd(null, "transition_command \"disconnect\";");
}
protected override bool ShouldUpdateRunStopwatch()
{
return base.livingPlayerCount > 0;
}
public override bool ShouldAllowNonChampionBossSpawn()
{
return true;
}
private void UNetVersion()
{
}
public override bool OnSerialize(NetworkWriter writer, bool forceAll)
{
bool flag = base.OnSerialize(writer, forceAll);
if (forceAll)
{
writer.WritePackedUInt32(serverSeedCycle);
return true;
}
bool flag2 = false;
if ((base.syncVarDirtyBits & 0x40u) != 0)
{
if (!flag2)
{
writer.WritePackedUInt32(base.syncVarDirtyBits);
flag2 = true;
}
writer.WritePackedUInt32(serverSeedCycle);
}
if (!flag2)
{
writer.WritePackedUInt32(base.syncVarDirtyBits);
}
return flag2 || flag;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
base.OnDeserialize(reader, initialState);
if (initialState)
{
serverSeedCycle = reader.ReadPackedUInt32();
return;
}
int num = (int)reader.ReadPackedUInt32();
if (((uint)num & 0x40u) != 0)
{
serverSeedCycle = reader.ReadPackedUInt32();
}
}
public override void PreStartClient()
{
base.PreStartClient();
}
}