using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
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 Data;
using ExpandWorld.Event;
using ExpandWorld.Spawn;
using ExpandWorldData;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ServerSync;
using Service;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ExpandWorldEvents")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+91ca50a2063154e0191cea139096bb0af752588b")]
[assembly: AssemblyProduct("ExpandWorldEvents")]
[assembly: AssemblyTitle("ExpandWorldEvents")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 ExpandWorld
{
public class Configuration
{
public static ConfigEntry<bool> configMultipleEvents;
public static ConfigEntry<string> configEventMinimumDistance;
public static ConfigEntry<bool> configCheckPerPlayer;
public static ConfigEntry<string> configEventInterval;
public static ConfigEntry<string> configEventChance;
public static CustomSyncedValue<string> valueEventData;
public static bool MultipleEvents => configMultipleEvents.Value;
public static float EventMinimumDistance => ConfigWrapper.Floats[configEventMinimumDistance];
public static bool CheckPerPlayer => configCheckPerPlayer.Value;
public static float EventInterval => ConfigWrapper.Floats[configEventInterval];
public static float EventChance => ConfigWrapper.Floats[configEventChance];
public static void Init(ConfigWrapper wrapper)
{
string text = "1. General";
configMultipleEvents = wrapper.Bind<bool>(text, "Multiple events", false, false, "If enabled, multiple events can be active at the same time.", true);
configCheckPerPlayer = wrapper.Bind<bool>(text, "Check per player", false, false, "If enabled, the event check is done separately for each player.", true);
configEventMinimumDistance = wrapper.BindFloat(text, "Minimum distance between events", 100f, false, "The minimum distance between events.", true);
configEventChance = wrapper.BindFloat(text, "Random event chance", 20f, false, "The chance to try starting a random event.", true);
configEventChance.SettingChanged += delegate
{
RandomEventSystem.Setup(RandEventSystem.instance);
};
configEventInterval = wrapper.BindFloat(text, "Random event interval", 46f, false, "How often the random events are checked (minutes).", true);
configEventInterval.SettingChanged += delegate
{
RandomEventSystem.Setup(RandEventSystem.instance);
};
RandomEventSystem.Setup(RandEventSystem.instance);
valueEventData = wrapper.AddValue("event_data");
((CustomSyncedValueBase)valueEventData).ValueChanged += delegate
{
Manager.FromSetting(valueEventData.Value);
};
}
}
[HarmonyPatch(typeof(RandEventSystem), "Awake")]
public class RandomEventSystem
{
public static void Setup(RandEventSystem rs)
{
if (Object.op_Implicit((Object)(object)rs))
{
rs.m_eventChance = Configuration.EventChance;
rs.m_eventIntervalMin = Configuration.EventInterval;
}
}
private static void Postfix(RandEventSystem __instance)
{
Setup(__instance);
}
}
[BepInPlugin("expand_world_events", "Expand World Events", "1.11")]
[BepInDependency("expand_world_data", "1.27")]
public class EWE : BaseUnityPlugin
{
public const string GUID = "expand_world_events";
public const string NAME = "Expand World Events";
public const string VERSION = "1.11";
public static ConfigSync ConfigSync = new ConfigSync("expand_world_events")
{
DisplayName = "Expand World Events",
CurrentVersion = "1.11",
ModRequired = true,
IsLocked = true
};
public void Awake()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
Configuration.Init(new ConfigWrapper("expand_events_config", ((BaseUnityPlugin)this).Config, ConfigSync, (Action)delegate
{
}));
new Harmony("expand_world_events").PatchAll();
try
{
Yaml.SetupWatcher(((BaseUnityPlugin)this).Config);
if (Configuration.DataReload)
{
Manager.SetupWatcher();
}
}
catch (Exception ex)
{
Log.Error(ex.StackTrace);
}
}
public static RandomEvent GetCurrentRandomEvent(Vector3 pos)
{
//IL_0007: 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)
if (Configuration.MultipleEvents)
{
return MultipleEvents.Events.OrderBy((MultiEvent x) => Utils.DistanceXZ(x.Event.m_pos, pos)).FirstOrDefault()?.Event;
}
return RandEventSystem.instance.GetCurrentRandomEvent();
}
private void OnDestroy()
{
((BaseUnityPlugin)this).Config.Save();
}
}
}
namespace ExpandWorld.Spawn
{
public class Data
{
public string prefab = "";
[DefaultValue(true)]
public bool enabled = true;
[DefaultValue("")]
public string biome = "";
[DefaultValue("")]
public string biomeArea = "";
[DefaultValue(100f)]
public float spawnChance = 100f;
public int maxSpawned = 1;
public float spawnInterval;
[DefaultValue(1)]
public int maxLevel = 1;
[DefaultValue(1)]
public int minLevel = 1;
[DefaultValue(-10000f)]
public float minAltitude = -10000f;
[DefaultValue(10000f)]
public float maxAltitude = 10000f;
[DefaultValue(true)]
public bool spawnAtDay = true;
[DefaultValue(true)]
public bool spawnAtNight = true;
[DefaultValue("")]
public string requiredGlobalKey = "";
[DefaultValue("")]
public string requiredEnvironments = "";
public float spawnDistance = 10f;
[DefaultValue(0f)]
public float spawnRadiusMin;
[DefaultValue(0f)]
public float spawnRadiusMax;
[DefaultValue(1)]
public int groupSizeMin = 1;
[DefaultValue(1)]
public int groupSizeMax = 1;
[DefaultValue(0f)]
public float groupRadius;
[DefaultValue(0f)]
public float minTilt;
[DefaultValue(35f)]
public float maxTilt = 35f;
[DefaultValue(true)]
public bool inForest = true;
[DefaultValue(true)]
public bool outsideForest = true;
[DefaultValue(false)]
public bool canSpawnCloseToPlayer;
[DefaultValue(false)]
public bool insidePlayerBase;
[DefaultValue(false)]
public bool inLava;
[DefaultValue(true)]
public bool outsideLava = true;
[DefaultValue(0f)]
public float minOceanDepth;
[DefaultValue(0f)]
public float maxOceanDepth;
[DefaultValue(false)]
public bool huntPlayer;
[DefaultValue(0.5f)]
public float groundOffset = 0.5f;
[DefaultValue(0f)]
public float groundOffsetRandom;
[DefaultValue(0f)]
public float levelUpMinCenterDistance;
[DefaultValue(-1f)]
public float overrideLevelupChance = -1f;
[DefaultValue("")]
public string faction = "";
[DefaultValue("")]
public string data = "";
[DefaultValue(null)]
public string[]? objects;
}
public class Loader
{
public static Dictionary<SpawnData, DataEntry?> Data = new Dictionary<SpawnData, DataEntry>();
public static Dictionary<SpawnData, List<BlueprintObject>> Objects = new Dictionary<SpawnData, List<BlueprintObject>>();
private static readonly int HashFaction = StringExtensionMethods.GetStableHashCode("faction");
public static SpawnData FromData(Data data)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: 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_003f: 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_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: 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)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Expected O, but got Unknown
//IL_0231: Unknown result type (might be due to invalid IL or missing references)
//IL_0237: Expected O, but got Unknown
SpawnData val = new SpawnData
{
m_prefab = DataManager.ToPrefab(data.prefab),
m_enabled = data.enabled,
m_biome = DataManager.ToBiomes(data.biome),
m_biomeArea = DataManager.ToBiomeAreas(data.biomeArea),
m_maxSpawned = data.maxSpawned,
m_spawnInterval = data.spawnInterval,
m_spawnChance = data.spawnChance,
m_spawnDistance = data.spawnDistance,
m_spawnRadiusMin = data.spawnRadiusMin,
m_spawnRadiusMax = data.spawnRadiusMax,
m_requiredGlobalKey = data.requiredGlobalKey,
m_requiredEnvironments = DataManager.ToList(data.requiredEnvironments, true),
m_groupSizeMin = data.groupSizeMin,
m_groupSizeMax = data.groupSizeMax,
m_spawnAtDay = data.spawnAtDay,
m_spawnAtNight = data.spawnAtNight,
m_groupRadius = data.groupRadius,
m_minAltitude = data.minAltitude,
m_maxAltitude = data.maxAltitude,
m_minTilt = data.minTilt,
m_maxTilt = data.maxTilt,
m_inForest = data.inForest,
m_outsideForest = data.outsideForest,
m_minOceanDepth = data.minOceanDepth,
m_maxOceanDepth = data.maxOceanDepth,
m_huntPlayer = data.huntPlayer,
m_groundOffset = data.groundOffset,
m_maxLevel = data.maxLevel,
m_minLevel = data.minLevel,
m_levelUpMinCenterDistance = data.levelUpMinCenterDistance,
m_overrideLevelupChance = data.overrideLevelupChance,
m_inLava = data.inLava,
m_outsideLava = data.outsideLava,
m_canSpawnCloseToPlayer = data.canSpawnCloseToPlayer,
m_insidePlayerBase = data.insidePlayerBase,
m_groundOffsetRandom = data.groundOffsetRandom
};
if (val.m_minAltitude == -10000f)
{
val.m_minAltitude = ((val.m_maxAltitude > 0f) ? 0f : (-1000f));
}
if (data.data != "")
{
Data[val] = DataHelper.Get(data.data);
}
if (data.faction != "")
{
DataEntry val2 = new DataEntry();
DataEntry val3 = val2;
if (val3.Strings == null)
{
val3.Strings = new Dictionary<int, IStringValue>();
}
val2.Strings[HashFaction] = DataValue.Simple(data.faction);
if (Data.ContainsKey(val))
{
Data[val] = DataHelper.Merge((DataEntry[])(object)new DataEntry[2]
{
Data[val],
val2
});
}
else
{
Data.Add(val, val2);
}
}
if (data.objects != null)
{
Objects[val] = data.objects.Select((string s) => Parse.Split(s, true, ',')).Select((Func<string[], BlueprintObject>)((string[] split) => new BlueprintObject(split[0], Parse.VectorXZY(split, 1), Quaternion.identity, Vector3.one, DataHelper.Get((split.Length > 5) ? split[5] : ""), Parse.Float(split, 4, 1f), false))).ToList();
}
return val;
}
public static Data ToData(SpawnData spawn)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
return new Data
{
prefab = ((Object)spawn.m_prefab).name,
enabled = spawn.m_enabled,
biome = DataManager.FromBiomes(spawn.m_biome),
biomeArea = DataManager.FromBiomeAreas(spawn.m_biomeArea),
maxSpawned = spawn.m_maxSpawned,
spawnInterval = spawn.m_spawnInterval,
spawnChance = spawn.m_spawnChance,
spawnDistance = spawn.m_spawnDistance,
spawnRadiusMin = spawn.m_spawnRadiusMin,
spawnRadiusMax = spawn.m_spawnRadiusMax,
requiredGlobalKey = spawn.m_requiredGlobalKey,
requiredEnvironments = DataManager.FromList((IEnumerable<string>)spawn.m_requiredEnvironments),
spawnAtDay = spawn.m_spawnAtDay,
spawnAtNight = spawn.m_spawnAtNight,
groupSizeMin = spawn.m_groupSizeMin,
groupSizeMax = spawn.m_groupSizeMax,
groupRadius = spawn.m_groupRadius,
minAltitude = spawn.m_minAltitude,
maxAltitude = spawn.m_maxAltitude,
minTilt = spawn.m_minTilt,
maxTilt = spawn.m_maxTilt,
inForest = spawn.m_inForest,
outsideForest = spawn.m_outsideForest,
minOceanDepth = spawn.m_minOceanDepth,
maxOceanDepth = spawn.m_maxOceanDepth,
huntPlayer = spawn.m_huntPlayer,
groundOffset = spawn.m_groundOffset,
maxLevel = spawn.m_maxLevel,
minLevel = spawn.m_minLevel,
levelUpMinCenterDistance = spawn.m_levelUpMinCenterDistance,
overrideLevelupChance = spawn.m_overrideLevelupChance,
inLava = spawn.m_inLava,
outsideLava = spawn.m_outsideLava,
canSpawnCloseToPlayer = spawn.m_canSpawnCloseToPlayer,
insidePlayerBase = spawn.m_insidePlayerBase,
groundOffsetRandom = spawn.m_groundOffsetRandom
};
}
}
[HarmonyPatch(typeof(SpawnSystem), "Spawn")]
public class SpawnZDO
{
private static void Prefix(SpawnData critter, Vector3 spawnPoint)
{
//IL_0016: 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)
if (Loader.Data.TryGetValue(critter, out DataEntry value))
{
DataHelper.Init(critter.m_prefab, spawnPoint, Quaternion.identity, (Vector3?)null, value);
}
}
private static string PrefabOverride(string prefab)
{
return prefab;
}
private static DataEntry? DataOverride(DataEntry? data, string prefab)
{
return data;
}
private static void Postfix(SpawnData critter, Vector3 spawnPoint)
{
//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_0042: Unknown result type (might be due to invalid IL or missing references)
if (!Loader.Objects.TryGetValue(critter, out List<BlueprintObject> value))
{
return;
}
foreach (BlueprintObject item in value)
{
if (!(item.Chance < 1f) || !(Random.value > item.Chance))
{
Spawn.BPO(item, spawnPoint, Quaternion.identity, Vector3.one, (Func<DataEntry, string, DataEntry>)DataOverride, (Func<string, string>)PrefabOverride, (List<GameObject>)null);
}
}
}
}
}
namespace ExpandWorld.Event
{
[HarmonyPatch(typeof(RandEventSystem))]
public class CheckPerPlayer
{
[HarmonyPatch("UpdateRandomEvent")]
[HarmonyPrefix]
private static void FixedUpdate(RandEventSystem __instance, float dt)
{
if (!Helper.IsClient() && Configuration.CheckPerPlayer && Game.m_eventRate != 0f)
{
if (RandEventSystem.s_randomEventNeedsRefresh)
{
RandEventSystem.RefreshPlayerEventData();
}
CheckGlobalEvent(__instance, dt);
CheckStandaloneEvents(__instance, dt);
}
}
private static void CheckGlobalEvent(RandEventSystem res, float dt)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
if (res.m_eventTimer + dt <= res.m_eventIntervalMin * 60f * Game.m_eventRate)
{
return;
}
res.m_eventTimer = 0f - dt;
foreach (PlayerEventData s_playerEventData in RandEventSystem.s_playerEventDatas)
{
if (!(Random.Range(0f, 100f) > res.m_eventChance / Game.m_eventRate))
{
List<KeyValuePair<RandomEvent, Vector3>> possibleRandomEvents = GetPossibleRandomEvents(res, s_playerEventData);
if (possibleRandomEvents.Count != 0)
{
KeyValuePair<RandomEvent, Vector3> keyValuePair = possibleRandomEvents[Random.Range(0, possibleRandomEvents.Count)];
res.SetRandomEvent(keyValuePair.Key, keyValuePair.Value);
}
}
}
}
private static void CheckStandaloneEvents(RandEventSystem res, float dt)
{
//IL_0012: 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_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
foreach (PlayerEventData s_playerEventData in RandEventSystem.s_playerEventDatas)
{
List<PlayerEventData> list = new List<PlayerEventData>(1) { s_playerEventData };
foreach (RandomEvent @event in res.m_events)
{
if (!@event.m_enabled || @event.m_standaloneChance == 0f || res.m_activeEvent == @event || @event.m_time + dt <= @event.m_standaloneInterval * Game.m_eventRate)
{
continue;
}
@event.m_time = 0f - dt;
if (!(Random.Range(0f, 100f) > @event.m_standaloneChance / Game.m_eventRate) && res.HaveGlobalKeys(@event, list))
{
List<Vector3> validEventPoints = res.GetValidEventPoints(@event, list);
if (validEventPoints.Count != 0)
{
res.SetRandomEvent(@event, validEventPoints[Random.Range(0, validEventPoints.Count)]);
}
}
}
}
}
private static List<KeyValuePair<RandomEvent, Vector3>> GetPossibleRandomEvents(RandEventSystem obj, PlayerEventData player)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
obj.m_lastPossibleEvents.Clear();
foreach (RandomEvent @event in obj.m_events)
{
List<PlayerEventData> list = new List<PlayerEventData>(1) { player };
if (@event.m_enabled && @event.m_random && obj.HaveGlobalKeys(@event, list))
{
List<Vector3> validEventPoints = obj.GetValidEventPoints(@event, list);
if (validEventPoints.Count != 0)
{
Vector3 value = validEventPoints[Random.Range(0, validEventPoints.Count)];
obj.m_lastPossibleEvents.Add(new KeyValuePair<RandomEvent, Vector3>(@event, value));
}
}
}
return obj.m_lastPossibleEvents;
}
private static bool IsValidEvent(RandEventSystem obj, RandomEvent ev, PlayerEventData player)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
List<PlayerEventData> list = new List<PlayerEventData>(1) { player };
if (!ev.m_enabled || !ev.m_random || !obj.HaveGlobalKeys(ev, list))
{
return false;
}
return obj.GetValidEventPoints(ev, list).Count > 0;
}
}
[HarmonyPatch(typeof(RandomEvent))]
public class Commands
{
[HarmonyPatch("OnStart")]
[HarmonyPostfix]
private static void OnStart(RandomEvent __instance)
{
//IL_0037: 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_0041: 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)
if (!Helper.IsClient())
{
RandomEvent @event = RandEventSystem.instance.GetEvent(__instance.m_name);
if (Loader.ExtraData.TryGetValue(@event, out ExtraData value) && value.StartCommands != null)
{
string[]? startCommands = value.StartCommands;
Vector3 pos = __instance.m_pos;
Quaternion identity = Quaternion.identity;
CommandManager.Run((IEnumerable<string>)startCommands, pos, ((Quaternion)(ref identity)).eulerAngles);
}
}
}
[HarmonyPatch("OnStop")]
[HarmonyPostfix]
private static void OnStop(RandomEvent __instance)
{
//IL_0037: 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_0041: 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)
if (!Helper.IsClient())
{
RandomEvent @event = RandEventSystem.instance.GetEvent(__instance.m_name);
if (Loader.ExtraData.TryGetValue(@event, out ExtraData value) && value.EndCommands != null)
{
string[]? endCommands = value.EndCommands;
Vector3 pos = __instance.m_pos;
Quaternion identity = Quaternion.identity;
CommandManager.Run((IEnumerable<string>)endCommands, pos, ((Quaternion)(ref identity)).eulerAngles);
}
}
}
}
public class Data
{
public string name = "";
[DefaultValue(true)]
public bool enabled = true;
[DefaultValue(0f)]
public float customChance;
[DefaultValue(0f)]
public float customInterval;
[DefaultValue(60f)]
public float duration = 60f;
[DefaultValue(96f)]
public float radius = 96f;
[DefaultValue(0f)]
public float spawnerDelay;
[DefaultValue("false")]
public string outsideBaseOnly = "false";
[DefaultValue("true")]
public string nearBaseOnly = "true";
[DefaultValue("")]
public string biome = "";
[DefaultValue("")]
public string requiredGlobalKeys = "";
[DefaultValue("")]
public string notRequiredGlobalKeys = "";
[DefaultValue("")]
public string requiredPlayerKeys = "";
[DefaultValue("")]
public string requiredPlayerKeysAll = "";
[DefaultValue("")]
public string notRequiredPlayerKeys = "";
[DefaultValue("")]
public string requiredKnownItems = "";
[DefaultValue("")]
public string notRequiredKnownItems = "";
[DefaultValue("")]
public string requiredEnvironments = "";
[DefaultValue("")]
public string startMessage = "";
[DefaultValue("")]
public string endMessage = "";
public string forceMusic = "";
[DefaultValue("")]
public string forceEnvironment = "";
public ExpandWorld.Spawn.Data[] spawns = Array.Empty<ExpandWorld.Spawn.Data>();
[DefaultValue(true)]
public bool pauseIfNoPlayerInArea = true;
[DefaultValue(true)]
public bool random = true;
[DefaultValue(100f)]
public float playerDistance = 100f;
[DefaultValue("")]
public string playerLimit = "";
[DefaultValue("")]
public string eventLimit = "";
[DefaultValue(null)]
public string[]? startCommands;
[DefaultValue(null)]
public string[]? endCommands;
}
public class ExtraData
{
public List<string> RequiredEnvironments = new List<string>();
public float PlayerDistance = 100f;
public Range<int>? PlayerLimit;
public int MinBaseValue = 3;
public int MaxBaseValue = int.MaxValue;
public Range<int>? EventLimit;
public string[]? StartCommands;
public string[]? EndCommands;
public ExtraData(Data data)
{
RequiredEnvironments = DataManager.ToList(data.requiredEnvironments, true);
PlayerDistance = data.playerDistance;
if (data.playerLimit != "")
{
PlayerLimit = Parse.IntRange(data.playerLimit);
}
if (data.eventLimit != "")
{
EventLimit = Parse.IntRange(data.eventLimit);
}
if (data.nearBaseOnly != "true")
{
MinBaseValue = Parse.Int(data.nearBaseOnly, 0);
}
if (data.outsideBaseOnly != "false")
{
MaxBaseValue = Parse.Int(data.outsideBaseOnly, 2);
MinBaseValue = 0;
}
StartCommands = data.startCommands;
EndCommands = data.endCommands;
}
}
public class Loader
{
public static Dictionary<RandomEvent, ExtraData> ExtraData = new Dictionary<RandomEvent, ExtraData>();
public static RandomEvent FromData(Data data)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: 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_00ac: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
//IL_019c: Expected O, but got Unknown
RandomEvent val = new RandomEvent
{
m_name = data.name,
m_spawn = (from s in data.spawns.Select(ExpandWorld.Spawn.Loader.FromData)
where Object.op_Implicit((Object)(object)s.m_prefab)
select s).ToList(),
m_enabled = data.enabled,
m_random = data.random,
m_duration = data.duration,
m_nearBaseOnly = (data.nearBaseOnly != "false"),
m_pauseIfNoPlayerInArea = data.pauseIfNoPlayerInArea,
m_biome = DataManager.ToBiomes(data.biome),
m_requiredGlobalKeys = DataManager.ToList(data.requiredGlobalKeys, true),
m_notRequiredGlobalKeys = DataManager.ToList(data.notRequiredGlobalKeys, true),
m_altRequiredPlayerKeysAny = DataManager.ToList(data.requiredPlayerKeys, true),
m_altRequiredPlayerKeysAll = DataManager.ToList(data.requiredPlayerKeysAll, true),
m_altNotRequiredPlayerKeys = DataManager.ToList(data.notRequiredPlayerKeys, true),
m_altRequiredKnownItems = DataManager.ToItemList(data.requiredKnownItems, true),
m_altRequiredNotKnownItems = DataManager.ToItemList(data.notRequiredKnownItems, true),
m_startMessage = data.startMessage,
m_endMessage = data.endMessage,
m_forceMusic = data.forceMusic,
m_forceEnvironment = data.forceEnvironment,
m_eventRange = data.radius,
m_standaloneChance = data.customChance,
m_standaloneInterval = data.customInterval,
m_spawnerDelay = data.spawnerDelay
};
ExtraData[val] = new ExtraData(data);
return val;
}
public static Data ToData(RandomEvent random)
{
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
return new Data
{
name = random.m_name,
spawns = random.m_spawn.Select(ExpandWorld.Spawn.Loader.ToData).ToArray(),
enabled = random.m_enabled,
random = random.m_random,
duration = random.m_duration,
nearBaseOnly = (random.m_nearBaseOnly ? "true" : "false"),
pauseIfNoPlayerInArea = random.m_pauseIfNoPlayerInArea,
biome = DataManager.FromBiomes(random.m_biome),
requiredGlobalKeys = DataManager.FromList((IEnumerable<string>)random.m_requiredGlobalKeys),
notRequiredGlobalKeys = DataManager.FromList((IEnumerable<string>)random.m_notRequiredGlobalKeys),
requiredPlayerKeys = DataManager.FromList((IEnumerable<string>)random.m_altRequiredPlayerKeysAny),
requiredPlayerKeysAll = DataManager.FromList((IEnumerable<string>)random.m_altRequiredPlayerKeysAll),
notRequiredPlayerKeys = DataManager.FromList((IEnumerable<string>)random.m_altNotRequiredPlayerKeys),
requiredKnownItems = DataManager.FromList((IEnumerable<ItemDrop>)random.m_altRequiredKnownItems),
notRequiredKnownItems = DataManager.FromList((IEnumerable<ItemDrop>)random.m_altRequiredNotKnownItems),
startMessage = random.m_startMessage,
endMessage = random.m_endMessage,
forceMusic = random.m_forceMusic,
forceEnvironment = random.m_forceEnvironment,
radius = random.m_eventRange,
customChance = random.m_standaloneChance,
customInterval = random.m_standaloneInterval,
spawnerDelay = random.m_spawnerDelay
};
}
}
[HarmonyPatch(typeof(RandEventSystem), "SetRandomEvent")]
[HarmonyPriority(800)]
public class MultipleConfigurationsPerEvent
{
private static void Prefix(RandEventSystem __instance, ref RandomEvent ev)
{
ev = __instance.GetEvent(ev?.m_name);
}
}
public class Manager
{
public static string FileName = "expand_events.yaml";
public static string FilePath = Path.Combine(Yaml.Directory, FileName);
public static string Pattern = "expand_events*.yaml";
public static List<RandomEvent> Originals = new List<RandomEvent>();
public static bool LoadDelayed = false;
public static void ToFile()
{
if (!Helper.IsClient() && !File.Exists(FilePath))
{
string contents = Yaml.Serializer().Serialize((object)RandEventSystem.instance.m_events.Select(Loader.ToData).ToList());
File.WriteAllText(FilePath, contents);
}
}
public static void FromFile()
{
if (!Helper.IsClient())
{
Set(DataManager.Read(Pattern));
RandEventSystem.instance.m_events.Distinct(new Comparer());
Configuration.valueEventData.Value = Yaml.Serializer().Serialize((object)RandEventSystem.instance.m_events.Select(Loader.ToData).ToList());
}
}
public static void FromSetting(string yaml)
{
if (!LoadDelayed && Helper.IsClient())
{
Set(yaml);
}
}
private static void Set(string yaml)
{
if (Helper.IsServer() && Originals.Count == 0)
{
List<RandomEvent> events = RandEventSystem.instance.m_events;
List<RandomEvent> list = new List<RandomEvent>(events.Count);
list.AddRange(events);
Originals = list;
}
Loader.ExtraData.Clear();
if (yaml == "")
{
return;
}
try
{
List<RandomEvent> list2 = Yaml.Deserialize<Data>(yaml, FileName).Select(Loader.FromData).ToList();
if (list2.Count == 0)
{
Log.Warning("Failed to load any event data.");
}
else if (!Configuration.DataMigration || !Helper.IsServer() || !AddMissingEntries(list2))
{
Log.Info($"Reloading event data ({list2.Count} entries).");
RandEventSystem.instance.m_events = list2;
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
Log.Error(ex.StackTrace);
}
}
private static bool AddMissingEntries(List<RandomEvent> entries)
{
HashSet<string> missingKeys = Originals.Select((RandomEvent e) => e.m_name).Distinct().ToHashSet();
foreach (RandomEvent entry in entries)
{
missingKeys.Remove(entry.m_name);
}
if (missingKeys.Count == 0)
{
return false;
}
List<RandomEvent> list = Originals.Where((RandomEvent item) => missingKeys.Contains(item.m_name)).ToList();
Log.Warning($"Adding {list.Count} missing events to the expand_events.yaml file.");
foreach (RandomEvent item in list)
{
Log.Warning(item.m_name);
}
string text = File.ReadAllText(FilePath);
string text2 = Yaml.Serializer().Serialize((object)list.Select(Loader.ToData));
text = text + "\n" + text2;
File.WriteAllText(FilePath, text);
return true;
}
public static void SetupWatcher()
{
Yaml.SetupWatcher(Pattern, (Action)FromFile);
}
}
[HarmonyPatch(typeof(ZNet), "Awake")]
public class DelayContentLoad
{
private static void Prefix()
{
Manager.LoadDelayed = true;
}
}
[HarmonyPatch(typeof(ZoneSystem), "Start")]
[HarmonyPriority(0)]
public class InitializeContent
{
private static void Postfix()
{
if (Helper.IsServer())
{
Manager.ToFile();
Manager.FromFile();
}
else if (Manager.LoadDelayed)
{
Manager.LoadDelayed = false;
Manager.FromSetting(Configuration.valueEventData.Value);
}
}
}
public class Comparer : IEqualityComparer<RandomEvent>
{
public bool Equals(RandomEvent x, RandomEvent y)
{
return x.m_name == y.m_name;
}
public int GetHashCode(RandomEvent obj)
{
return StringExtensionMethods.GetStableHashCode(obj.m_name);
}
}
[HarmonyPatch(typeof(RandEventSystem), "InValidBiome")]
public class ExtraChecks
{
private static bool Postfix(bool result, RandomEvent ev, Vector3 point)
{
//IL_0016: 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_003c: Unknown result type (might be due to invalid IL or missing references)
if (!result)
{
return false;
}
if (!Loader.ExtraData.TryGetValue(ev, out ExtraData value))
{
return true;
}
if (!EnvCheck(point, value.RequiredEnvironments))
{
return false;
}
if (!PlayerCheck(point, value.PlayerLimit, value.PlayerDistance))
{
return false;
}
if (!EventCheck(point, value.EventLimit))
{
return false;
}
return true;
}
private static bool EnvCheck(Vector3 pos, List<string> required)
{
//IL_000f: 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_0015: 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_0031: Unknown result type (might be due to invalid IL or missing references)
if (required.Count == 0)
{
return true;
}
Biome biome = WorldGenerator.instance.GetBiome(pos);
EnvMan instance = EnvMan.instance;
List<EnvEntry> availableEnvironments = instance.GetAvailableEnvironments(biome);
if (availableEnvironments == null || availableEnvironments.Count == 0)
{
return false;
}
State state = Random.state;
Random.InitState((int)((long)ZNet.instance.GetTimeSeconds() / instance.m_environmentDuration));
EnvSetup val = instance.SelectWeightedEnvironment(availableEnvironments);
Random.state = state;
return required.Contains(val.m_name.ToLower());
}
private static bool PlayerCheck(Vector3 pos, Range<int>? limit, float distance)
{
//IL_0007: 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)
if (limit == null)
{
return true;
}
int num = RandEventSystem.s_playerEventDatas.Where((PlayerEventData p) => Utils.DistanceXZ(pos, p.position) <= distance).Count();
if (limit.Min <= num)
{
return num <= limit.Max;
}
return false;
}
private static bool EventCheck(Vector3 pos, Range<int>? limit)
{
//IL_0007: 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)
if (limit == null)
{
return true;
}
if (!Configuration.MultipleEvents)
{
return true;
}
int num = MultipleEvents.Events.Where((MultiEvent p) => Utils.DistanceXZ(pos, p.Event.m_pos) <= Configuration.EventMinimumDistance).Sum((MultiEvent p) => p.Count);
if (limit.Min <= num)
{
return num <= limit.Max;
}
return false;
}
}
[HarmonyPatch(typeof(RandEventSystem), "CheckBase")]
public class CheckBase
{
private static bool Prefix(RandomEvent ev, PlayerEventData player, ref bool __result)
{
//IL_0012: 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)
if (!Loader.ExtraData.TryGetValue(ev, out ExtraData value))
{
return true;
}
__result = player.baseValue >= value.MinBaseValue && player.baseValue <= value.MaxBaseValue;
return false;
}
}
public class MultiEvent
{
public RandomEvent Event;
public int Count;
public MultiEvent(RandomEvent ev, int count)
{
Event = ev;
Count = count;
base..ctor();
}
}
[HarmonyPatch(typeof(RandEventSystem))]
public class MultipleEvents
{
public static readonly List<MultiEvent> Events = new List<MultiEvent>();
[HarmonyPatch("FixedUpdate")]
[HarmonyPrefix]
private static bool FixedUpdate(RandEventSystem __instance)
{
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
RandEventSystem __instance2 = __instance;
if (Helper.IsClient() || !Configuration.MultipleEvents)
{
return true;
}
float fixedDeltaTime = Time.fixedDeltaTime;
RandEventSystem val = __instance2;
val.UpdateForcedEvents(fixedDeltaTime);
val.UpdateRandomEvent(fixedDeltaTime);
RandomEvent forcedEvent = val.m_forcedEvent;
if (forcedEvent != null)
{
forcedEvent.Update(true, true, true, fixedDeltaTime);
}
List<MultiEvent> list = Events.Where(delegate(MultiEvent x)
{
bool flag = __instance2.IsAnyPlayerInEventArea(x.Event);
return x.Event.Update(true, true, flag, Time.fixedDeltaTime);
}).ToList();
list.ForEach(delegate(MultiEvent x)
{
x.Event.OnStop();
});
Events.RemoveAll(list.Contains);
if (val.m_forcedEvent != null)
{
val.SetActiveEvent(val.m_forcedEvent, false);
}
else if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
RandomEvent val2 = (val.m_randomEvent = Events.OrderBy((MultiEvent x) => Utils.DistanceXZ(x.Event.m_pos, ((Component)Player.m_localPlayer).transform.position)).FirstOrDefault()?.Event);
if (val2 != null && val.IsInsideRandomEventArea(val2, ((Component)Player.m_localPlayer).transform.position))
{
__instance2.SetActiveEvent(val2, false);
}
else
{
val.SetActiveEvent((RandomEvent)null, false);
}
}
else
{
val.SetActiveEvent((RandomEvent)null, false);
}
return false;
}
[HarmonyPatch("SetRandomEvent")]
[HarmonyPrefix]
private static bool SetRandomEvent(RandEventSystem __instance, RandomEvent ev, Vector3 pos)
{
//IL_0007: 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_00cf: 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 (Helper.IsClient() || !Configuration.MultipleEvents)
{
return true;
}
if (ev == null)
{
List<MultiEvent> list = Events.ToList();
list.ForEach(delegate(MultiEvent x)
{
x.Event.OnStop();
});
Events.RemoveAll(list.Contains);
return false;
}
List<MultiEvent> list2 = Events.Where((MultiEvent x) => Utils.DistanceXZ(x.Event.m_pos, pos) < Configuration.EventMinimumDistance).ToList();
list2.ForEach(delegate(MultiEvent x)
{
x.Event.OnStop();
});
Events.RemoveAll(list2.Contains);
RandomEvent val = ev.Clone();
val.m_pos = pos;
val.OnStart();
int count = list2.Sum((MultiEvent x) => x.Count) + 1;
Events.Add(new MultiEvent(val, count));
__instance.SendCurrentRandomEvent();
return false;
}
[HarmonyPatch("SendCurrentRandomEvent")]
[HarmonyPrefix]
private static bool SendCurrentRandomEvent()
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
if (Helper.IsClient() || !Configuration.MultipleEvents || Events.Count == 0)
{
return true;
}
if (Events.Count == 1)
{
RandomEvent @event = Events.First().Event;
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "SetEvent", new object[3] { @event.m_name, @event.m_time, @event.m_pos });
return false;
}
ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
if (peer.m_rpc != null)
{
RandomEvent event2 = Events.OrderBy((MultiEvent x) => Utils.DistanceXZ(x.Event.m_pos, peer.m_refPos)).First().Event;
ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "SetEvent", new object[3] { event2.m_name, event2.m_time, event2.m_pos });
}
});
return false;
}
}
}
