using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using On.RoR2;
using On.RoR2.Artifacts;
using On.RoR2.Networking;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RoR2;
using RoR2.Artifacts;
using RoR2.Networking;
using RoR2.UI;
using Unity;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("InstanceLootPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("InstanceLootPlugin")]
[assembly: AssemblyTitle("InstanceLootPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace InstanceLootPlugin
{
public class DropRateManager
{
private ConfigEntry<bool> EnableBadLuckProtection;
private ConfigEntry<bool> EnableSwarmsScaling;
private ConfigEntry<float> DropChanceMultiplier;
private ConfigEntry<float> BaseDropChance;
private ConfigEntry<float> MinimumDropChance;
public DropRateManager(ConfigEntry<bool> enableBadLuckProtection, ConfigEntry<bool> enableSwarmsScaling, ConfigEntry<float> dropChanceMultiplier, ConfigEntry<float> baseDropChance, ConfigEntry<float> minimumDropChance)
{
EnableBadLuckProtection = enableBadLuckProtection;
EnableSwarmsScaling = enableSwarmsScaling;
DropChanceMultiplier = dropChanceMultiplier;
BaseDropChance = baseDropChance;
MinimumDropChance = minimumDropChance;
}
public float GetPlayerAwareBaseDropChance(int playerCount, float dropChance)
{
float num = 1f / (float)playerCount;
float num2 = num * DropChanceMultiplier.Value;
float num3 = Math.Max(BaseDropChance.Value * num2, MinimumDropChance.Value);
if (!dropChance.Equals(num3))
{
dropChance = num3;
Log.Debug($"Using dropRate of {dropChance}% (base={BaseDropChance.Value}, multiplier={DropChanceMultiplier.Value}, playerCount={playerCount}, minimumDropChance={MinimumDropChance.Value}");
}
return dropChance;
}
public float ComputeDropChance(bool isSwarmEnabled, float nativeDropChance, float nativeBaseDropChance, float dropChance)
{
float num = ((!(EnableSwarmsScaling.Value && isSwarmEnabled) || nativeDropChance == 0f) ? nativeDropChance : ((nativeDropChance - nativeBaseDropChance) * 0.6f + nativeBaseDropChance));
float num2 = nativeBaseDropChance / 5f;
float num3 = num / nativeBaseDropChance;
return dropChance * num2 * num3;
}
public bool NeedsBadLuckProtection(float actualDropChance, float time)
{
if (EnableBadLuckProtection.Value && DropRateTracker.cumulativeDropChance >= 100f && actualDropChance > 0f)
{
bool flag = DropRateTracker.expectedItems > (float)DropRateTracker.totalItemDrops;
float num = (float)DropRateTracker.totalItemDrops / (time / 60f);
return flag || (double)num < 0.8;
}
return false;
}
public float GetBadLuckProtectedDropChance(float dropChance)
{
float num = DropRateTracker.cumulativeDropChance - 100f;
float num2 = Math.Min(dropChance + num, 90f);
Log.Debug($"Bad Luck Protection triggered! ({dropChance}% => {num2}%)");
return num2;
}
}
public static class DropRateTracker
{
private static Dictionary<float, long> DropRateReport = new Dictionary<float, long>();
public static long totalItemDrops { get; private set; } = 0L;
public static float cumulativeDropChance { get; private set; } = 0f;
public static float expectedItems { get; private set; } = 0f;
public static void ResetTracker()
{
DropRateReport = new Dictionary<float, long>();
totalItemDrops = 0L;
cumulativeDropChance = 0f;
expectedItems = 0f;
}
public static void RegisterDropOpportunity(float dropChance)
{
cumulativeDropChance += dropChance;
expectedItems += (float)Math.Round(dropChance / 100f, 2);
if (DropRateReport.TryGetValue(dropChance, out var _))
{
DropRateReport[dropChance]++;
}
else
{
DropRateReport.Add(dropChance, 1L);
}
}
public static void RegisterItemDrop(CreatePickupInfo createPickupInfo)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
PickupIndex pickupIndex = ((CreatePickupInfo)(ref createPickupInfo)).pickupIndex;
if (((PickupIndex)(ref pickupIndex)).pickupDef != null)
{
pickupIndex = ((CreatePickupInfo)(ref createPickupInfo)).pickupIndex;
PickupDef pickupDef = ((PickupIndex)(ref pickupIndex)).pickupDef;
if (pickupDef.coinValue == 0 && pickupDef.nameToken != "PICKUP_LUNAR_COIN")
{
cumulativeDropChance = 0f;
totalItemDrops++;
}
}
}
public static void LogReport()
{
if (Run.instance == null || !((Behaviour)Run.instance).isActiveAndEnabled)
{
return;
}
long num = DropRateReport.Values.Aggregate(0L, (long i, long l) => i + l);
if (num != 0)
{
string text = DropRateReport.Keys.OrderByDescending((float f) => f).Aggregate("Kills by Drop Rate", (string s, float f) => $"{s}\n {f}%: {DropRateReport[f]} kills");
float runStopwatch = Run.instance.GetRunStopwatch();
float num2 = runStopwatch / 60f;
float num3 = DropRateReport.Keys.Aggregate(0f, (float f, float f1) => f + (float)DropRateReport[f1] * f1) / (float)num;
string text2 = "------ DROP RATE RUN REPORT -----\n";
text2 += $"Stage: {Run.instance.stageClearCount + 1}\n";
text2 += $"Run Duration: {runStopwatch}s\n";
text2 += $"Total kills: {num}\n";
text2 += $"Total items: {totalItemDrops}\n";
text2 += $"Theoretical Average Drop Rate: {num3}%\n";
text2 += $"Actual Average Drop Rate: {(float)totalItemDrops / (float)num * 100f}%\n";
text2 += $"Drops per Minute: {Math.Round((float)totalItemDrops / num2, 2)}\n";
text2 = text2 + text + "\n";
text2 += "------ END OF REPORT -----";
Log.Info(text2);
}
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("programit.BalancedInstanceBasedLoot", "BalancedInstanceBasedLoot", "2.0.8")]
public class InstanceLootPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private static class <>O
{
public static hook_GetExpAdjustedDropChancePercent <0>__Util_GetExpAdjustedDropChancePercent;
public static NetworkMessageDelegate <1>__HandlePickupMessage;
}
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static hook_DropRewards <>9__36_0;
public static Func<PlayerCharacterMasterController, bool> <>9__51_0;
internal void <OnEnable>b__36_0(orig_DropRewards orig, BossGroup self)
{
if (EnablePlayerDropRateScaling.Value && IsModHooked)
{
self.scaleRewardsByPlayerCount = false;
}
orig.Invoke(self);
}
internal bool <GetPlayerCount>b__51_0(PlayerCharacterMasterController pc)
{
return pc.isConnected;
}
}
public const string PluginGUID = "programit.BalancedInstanceBasedLoot";
public const string PluginAuthor = "programit";
public const string PluginName = "BalancedInstanceBasedLoot";
public const string PluginVersion = "2.0.8";
public static float dropChance = 5f;
private static bool IsModHooked = false;
private bool forceDisabled = false;
private static bool useManualDropRate = false;
private static DropRateManager dropRateManager;
private static ConfigEntry<float> DropChanceMultiplier { get; set; }
private static ConfigEntry<float> MinimumDropChance { get; set; }
private static ConfigEntry<float> BaseDropChance { get; set; }
private static ConfigEntry<bool> EnablePlayerDropRateScaling { get; set; }
private static ConfigEntry<bool> EnableSwarmsScaling { get; set; }
private static ConfigEntry<bool> EnableBadLuckProtection { get; set; }
public void Awake()
{
Log.Init(((BaseUnityPlugin)this).Logger);
DropChanceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DropChanceMultiplier", 1f, "Manipulate drop rate. Use `0.5` to halve or `2` to double.");
MinimumDropChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MinimumDropChance", 1f, "The lowest possible drop chance when player count scaling is active.");
EnablePlayerDropRateScaling = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnablePlayerBasedDropRateScaling", true, "Enabling this will reduce drop rates to account for shared loot.");
EnableSwarmsScaling = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableSwarmsScaling", true, "Enabling this will (correctly) reduce drop rates for Artifact of Swarms.");
EnableBadLuckProtection = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableBadLuckProtection", true, "Enabling this will increase drop rate consistency with low drop rates.");
BaseDropChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "BaseDropChance", 5f, "Base item drop chance. It is recommended to leave this at the default value.");
dropChance = BaseDropChance.Value;
dropRateManager = new DropRateManager(EnableBadLuckProtection, EnableSwarmsScaling, DropChanceMultiplier, BaseDropChance, MinimumDropChance);
}
private void Update()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
if (!Input.GetKeyDown((KeyCode)284) || !IsModHooked)
{
return;
}
try
{
Object.FindObjectsOfType<RuleBookViewer>();
PickupDisplay[] array = Object.FindObjectsOfType<PickupDisplay>();
Vector3 position = ((MPEventSystem)EventSystem.current).localUser.cachedMaster.GetBodyObject().transform.position;
float num = 10f;
Vector3 position2 = default(Vector3);
for (int i = 0; i < array.Length; i++)
{
PickupDisplay val = array[i];
if (((Object)val.highlight).name.StartsWith("CommandCube"))
{
float num2 = (float)i * MathF.PI * 2f / (float)array.Length;
((Vector3)(ref position2))..ctor(position.x + Mathf.Cos(num2) * num, position.y, position.z + Mathf.Sin(num2) * num);
((Component)val).gameObject.transform.position = position2;
}
}
}
catch (NullReferenceException)
{
((BaseUnityPlugin)this).Logger.LogDebug((object)"Failed to pull CommandCubes with F3 - most likely because there were none.");
}
}
private void OnApplicationFocus(bool hasFocus)
{
if (hasFocus)
{
ReevaluateLifecycle();
}
}
private void OnEnable()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
object obj = <>c.<>9__36_0;
if (obj == null)
{
hook_DropRewards val = delegate(orig_DropRewards orig, BossGroup self)
{
if (EnablePlayerDropRateScaling.Value && IsModHooked)
{
self.scaleRewardsByPlayerCount = false;
}
orig.Invoke(self);
};
<>c.<>9__36_0 = val;
obj = (object)val;
}
BossGroup.DropRewards += (hook_DropRewards)obj;
SceneManager.activeSceneChanged += delegate(Scene oldScene, Scene newScene)
{
bool flag = ((Scene)(ref newScene)).name == "loadingbasic" || ((Scene)(ref newScene)).name == "intro" || ((Scene)(ref newScene)).name == "splash" || ((Scene)(ref newScene)).name == "title" || ((Scene)(ref newScene)).name == "eclipseworld" || ((Scene)(ref newScene)).name == "infinitetowerworld" || ((Scene)(ref newScene)).name == "lobby";
forceDisabled = ((Scene)(ref newScene)).name == "artifactworld" || flag;
if (flag)
{
useManualDropRate = false;
DropRateTracker.ResetTracker();
}
ReevaluateLifecycle();
};
NetworkingAPI.RegisterMessageType<SpawnCustomMessage2>();
}
private void ReevaluateLifecycle()
{
if (EnablePlayerDropRateScaling.Value && IsSacrificeEnabled() && !useManualDropRate)
{
dropChance = dropRateManager.GetPlayerAwareBaseDropChance(GetPlayerCount(), dropChance);
}
if (forceDisabled)
{
if (IsModHooked)
{
Log.Warning("Force Disabled: Will remove hooks, even if Artifact of Command is enabled.");
UnHook();
}
else
{
Log.Debug("Force Disabled: Will not hook.");
}
return;
}
bool flag = IsCommandEnabled();
if (IsModHooked && !flag)
{
UnHook();
}
else if (!IsModHooked && flag)
{
Hook();
}
}
private void Hook()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading hooks");
object obj = <>O.<0>__Util_GetExpAdjustedDropChancePercent;
if (obj == null)
{
hook_GetExpAdjustedDropChancePercent val = Util_GetExpAdjustedDropChancePercent;
<>O.<0>__Util_GetExpAdjustedDropChancePercent = val;
obj = (object)val;
}
Util.GetExpAdjustedDropChancePercent += (hook_GetExpAdjustedDropChancePercent)obj;
NetworkMessageHandlerAttribute.RegisterClientMessages += new hook_RegisterClientMessages(NetworkMessageHandlerAttribute_RegisterClientMessages);
CommandArtifactManager.OnDropletHitGroundServer += new hook_OnDropletHitGroundServer(CommandArtifactManager_OnDropletHitGroundServer);
Interactor.AttemptInteraction += new hook_AttemptInteraction(Interactor_AttemptInteraction);
PickupPickerController.SubmitChoice += new hook_SubmitChoice(PickupPickerController_SubmitChoice);
GenericPickupController.CreatePickup += new hook_CreatePickup(GenericPickupController_CreatePickup);
IsModHooked = true;
}
private void UnHook()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
((BaseUnityPlugin)this).Logger.LogInfo((object)"Unloading hooks");
object obj = <>O.<0>__Util_GetExpAdjustedDropChancePercent;
if (obj == null)
{
hook_GetExpAdjustedDropChancePercent val = Util_GetExpAdjustedDropChancePercent;
<>O.<0>__Util_GetExpAdjustedDropChancePercent = val;
obj = (object)val;
}
Util.GetExpAdjustedDropChancePercent -= (hook_GetExpAdjustedDropChancePercent)obj;
NetworkMessageHandlerAttribute.RegisterClientMessages -= new hook_RegisterClientMessages(NetworkMessageHandlerAttribute_RegisterClientMessages);
CommandArtifactManager.OnDropletHitGroundServer -= new hook_OnDropletHitGroundServer(CommandArtifactManager_OnDropletHitGroundServer);
Interactor.AttemptInteraction -= new hook_AttemptInteraction(Interactor_AttemptInteraction);
PickupPickerController.SubmitChoice -= new hook_SubmitChoice(PickupPickerController_SubmitChoice);
GenericPickupController.CreatePickup -= new hook_CreatePickup(GenericPickupController_CreatePickup);
IsModHooked = false;
}
private GenericPickupController GenericPickupController_CreatePickup(orig_CreatePickup orig, ref CreatePickupInfo createPickupInfo)
{
return null;
}
private void PickupPickerController_SubmitChoice(orig_SubmitChoice orig, PickupPickerController self, int choiceIndex)
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
if ((ulong)choiceIndex >= (ulong)self.options.Length)
{
return;
}
ref Option reference = ref self.options[choiceIndex];
if (reference.available)
{
PickupIndexUnityEvent onPickupSelected = self.onPickupSelected;
if (onPickupSelected != null)
{
((UnityEvent<int>)(object)onPickupSelected).Invoke(reference.pickupIndex.value);
Log.Info($"Sending CreatePickup {self.options[choiceIndex].pickupIndex}");
NetMessageExtensions.Send((INetMessage)(object)new SpawnCustomMessage2(self.options[choiceIndex].pickupIndex, ((MPEventSystem)EventSystem.current).localUser.cachedMaster.GetBodyObject().transform.position), (NetworkDestination)2);
self.OnDisplayEnd((NetworkUIPromptController)null, (LocalUser)null, (CameraRigController)null);
}
}
}
private void Interactor_AttemptInteraction(orig_AttemptInteraction orig, Interactor self, GameObject interactableObject)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (((Object)interactableObject).name.StartsWith("CommandCube"))
{
PickupPickerController component = interactableObject.GetComponent<PickupPickerController>();
component.panelInstance = Object.Instantiate<GameObject>(component.panelPrefab, ((MPEventSystem)EventSystem.current).localUser.cameraRigController.hud.mainContainer.transform);
component.panelInstanceController = component.panelInstance.GetComponent<PickupPickerPanel>();
component.panelInstanceController.pickerController = component;
component.panelInstanceController.SetPickupOptions(component.options);
}
else
{
orig.Invoke(self, interactableObject);
}
}
private void CommandArtifactManager_OnDropletHitGroundServer(orig_OnDropletHitGroundServer orig, ref CreatePickupInfo createPickupInfo, ref bool shouldSpawn)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
DropRateTracker.RegisterItemDrop(createPickupInfo);
NetworkServer.SendToAll((short)969, (MessageBase)(object)new SpawnCustomMessage
{
position = createPickupInfo.position,
pickupIndex = ((CreatePickupInfo)(ref createPickupInfo)).pickupIndex
});
shouldSpawn = false;
}
private void NetworkMessageHandlerAttribute_RegisterClientMessages(orig_RegisterClientMessages orig, NetworkClient client)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
orig.Invoke(client);
object obj = <>O.<1>__HandlePickupMessage;
if (obj == null)
{
NetworkMessageDelegate val = SpawnCustomController.HandlePickupMessage;
<>O.<1>__HandlePickupMessage = val;
obj = (object)val;
}
client.RegisterHandler((short)969, (NetworkMessageDelegate)obj);
}
private static float Util_GetExpAdjustedDropChancePercent(orig_GetExpAdjustedDropChancePercent orig, float nativeBaseDropChance, GameObject characterBodyObject)
{
float num = orig.Invoke(nativeBaseDropChance, characterBodyObject);
float num2 = dropRateManager.ComputeDropChance(IsSwarmEnabled(), num, nativeBaseDropChance, dropChance);
Log.Debug($"DropChance: original_base={nativeBaseDropChance} original_final={num}; plugin_base={dropChance}; plugin_final={num2} (Character={((Object)characterBodyObject).name})");
DropRateTracker.RegisterDropOpportunity(num2);
if (dropRateManager.NeedsBadLuckProtection(num2, Run.instance.GetRunStopwatch()))
{
return dropRateManager.GetBadLuckProtectedDropChance(num2);
}
return num2;
}
[ConCommand(/*Could not decode attribute arguments.*/)]
private static void CCSetDropRate(ConCommandArgs args)
{
dropChance = ((ConCommandArgs)(ref args)).GetArgFloat(0);
useManualDropRate = true;
}
[ConCommand(/*Could not decode attribute arguments.*/)]
private static void CCGetDropRateReport(ConCommandArgs args)
{
if (IsModHooked)
{
DropRateTracker.LogReport();
}
}
private static bool IsSacrificeEnabled()
{
return RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled && RunArtifactManager.instance.IsArtifactEnabled(Artifacts.sacrificeArtifactDef);
}
private static bool IsCommandEnabled()
{
return RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled && RunArtifactManager.instance.IsArtifactEnabled(Artifacts.commandArtifactDef);
}
private static bool IsSwarmEnabled()
{
return RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled && RunArtifactManager.instance.IsArtifactEnabled(Artifacts.swarmsArtifactDef);
}
private int GetPlayerCount()
{
return PlayerCharacterMasterController.instances.Count((PlayerCharacterMasterController pc) => pc.isConnected);
}
}
internal static class Log
{
private static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
internal static void Debug(object data)
{
_logSource.LogDebug(data);
}
internal static void Error(object data)
{
_logSource.LogError(data);
}
internal static void Fatal(object data)
{
_logSource.LogFatal(data);
}
internal static void Info(object data)
{
_logSource.LogInfo(data);
}
internal static void Message(object data)
{
_logSource.LogMessage(data);
}
internal static void Warning(object data)
{
_logSource.LogWarning(data);
}
}
public class SpawnCustomController : NetworkBehaviour
{
[NetworkMessageHandler(msgType = 969, client = true)]
public static void HandlePickupMessage(NetworkMessage netMsg)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
SpawnCustomMessage spawnCustomMessage = new SpawnCustomMessage();
netMsg.ReadMessage<SpawnCustomMessage>(spawnCustomMessage);
Log.Info($"HandlePickupMessage {spawnCustomMessage.pickupIndex.value}");
CreatePickupDroplet(spawnCustomMessage.pickupIndex, spawnCustomMessage.position);
}
public static void CreatePickupDroplet(PickupIndex pickupIndex, Vector3 position)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
CreatePickupInfo val = default(CreatePickupInfo);
val.rotation = Quaternion.identity;
((CreatePickupInfo)(ref val)).pickupIndex = pickupIndex;
CreatePickupInfo val2 = val;
GameObject val3 = Object.Instantiate<GameObject>(CommandArtifactManager.commandCubePrefab, position, val2.rotation);
PickupIndexNetworker component = val3.GetComponent<PickupIndexNetworker>();
PickupPickerController component2 = val3.GetComponent<PickupPickerController>();
component2.SetOptionsInternal(PickupPickerController.GetOptionsFromPickupIndex(((CreatePickupInfo)(ref val2)).pickupIndex));
if (!NetworkServer.active)
{
((NetworkBehaviour)component2).SetDirtyBit(PickupPickerController.optionsDirtyBit);
}
component.NetworkpickupIndex = ((CreatePickupInfo)(ref val2)).pickupIndex;
if (Object.op_Implicit((Object)(object)component.pickupDisplay))
{
component.pickupDisplay.SetPickupIndex(((CreatePickupInfo)(ref val2)).pickupIndex, false);
}
}
public static void CreatePickupItem(PickupIndex pickupIndex, Vector3 position)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
if (NetworkServer.active)
{
CreatePickupInfo val = default(CreatePickupInfo);
val.rotation = Quaternion.identity;
val.position = position;
((CreatePickupInfo)(ref val)).pickupIndex = pickupIndex;
CreatePickupInfo val2 = val;
GameObject val3 = Object.Instantiate<GameObject>(val2.prefabOverride ?? GenericPickupController.pickupPrefab, position, val2.rotation);
GenericPickupController component = val3.GetComponent<GenericPickupController>();
if (Object.op_Implicit((Object)(object)component))
{
GenericPickupController val4 = component;
CreatePickupInfo val5 = val2;
val4.NetworkpickupIndex = ((CreatePickupInfo)(ref val5)).pickupIndex;
}
PickupIndexNetworker component2 = val3.GetComponent<PickupIndexNetworker>();
if (Object.op_Implicit((Object)(object)component2))
{
PickupIndexNetworker val6 = component2;
CreatePickupInfo val7 = val2;
val6.NetworkpickupIndex = ((CreatePickupInfo)(ref val7)).pickupIndex;
}
PickupPickerController component3 = val3.GetComponent<PickupPickerController>();
if (Object.op_Implicit((Object)(object)component3) && val2.pickerOptions != null)
{
component3.SetOptionsServer(val2.pickerOptions);
}
NetworkServer.Spawn(val3);
}
}
}
public class SpawnCustomMessage : MessageBase, INetMessage, ISerializableObject
{
public Vector3 position;
public PickupIndex pickupIndex;
public override void Serialize(NetworkWriter writer)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
writer.Write(position);
GeneratedNetworkCode._WritePickupIndex_None(writer, pickupIndex);
}
public override void Deserialize(NetworkReader reader)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
position = reader.ReadVector3();
pickupIndex = GeneratedNetworkCode._ReadPickupIndex_None(reader);
}
public void OnReceived()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
SpawnCustomController.CreatePickupItem(pickupIndex, position);
}
}
public struct SpawnCustomMessage2 : INetMessage, ISerializableObject
{
public Vector3 position;
public PickupIndex pickupIndex;
public void Serialize(NetworkWriter writer)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
writer.Write(position);
GeneratedNetworkCode._WritePickupIndex_None(writer, pickupIndex);
}
public void Deserialize(NetworkReader reader)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
position = reader.ReadVector3();
pickupIndex = GeneratedNetworkCode._ReadPickupIndex_None(reader);
}
public void OnReceived()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
SpawnCustomController.CreatePickupItem(pickupIndex, position);
}
public SpawnCustomMessage2(PickupIndex pickupIndex, Vector3 position)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
this.position = position;
this.pickupIndex = pickupIndex;
}
}
}
