using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
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.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Bloodstone.API;
using Bloodstone.Hooks;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ProjectM;
using RaidForge;
using VampireCommandFramework;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ForgeScheduler")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Helps Manages Game Modes")]
[assembly: AssemblyFileVersion("0.1.10.0")]
[assembly: AssemblyInformationalVersion("0.1.10+1.Branch.main.Sha.c33d0879382e1a0da34861ec55914ba7e637a80e")]
[assembly: AssemblyProduct("ForgeScheduler")]
[assembly: AssemblyTitle("ForgeScheduler")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.10.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 ForgeScheduler
{
[BepInPlugin("forgescheduler", "ForgeScheduler", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[Reloadable]
public class ForgeSchedulerPlugin : BasePlugin
{
public static ManualLogSource Logger;
private Harmony _harmony;
public ConfigFile ConfigFile { get; private set; }
public override void Load()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Expected O, but got Unknown
Logger = ((BasePlugin)this).Log;
string text = Path.Combine(Paths.ConfigPath, "ForgeScheduler");
Directory.CreateDirectory(text);
string text2 = Path.Combine(text, "RaidForge.cfg");
ConfigFile = new ConfigFile(text2, true);
_harmony = new Harmony("forgescheduler");
_harmony.PatchAll();
StartDateManager.Initialize();
RaidForgeScheduleManager.Initialize(ConfigFile, Logger);
CommandRegistry.RegisterAll();
Chat.OnChatMessage += new ChatEventHandler(OnChatMessage);
GameFrame.Initialize();
GameFrame.OnUpdate += new GameFrameUpdateEventHandler(OnFrameUpdate);
Logger.LogInfo((object)"ForgeScheduler Loaded.");
}
public override bool Unload()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
Chat.OnChatMessage -= new ChatEventHandler(OnChatMessage);
GameFrame.OnUpdate -= new GameFrameUpdateEventHandler(OnFrameUpdate);
GameFrame.Uninitialize();
CommandRegistry.UnregisterAssembly();
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
return true;
}
private void OnFrameUpdate()
{
RaidForgeScheduleManager.OnSchedulerUpdate();
}
private void OnChatMessage(VChatEvent ev)
{
//IL_0002: 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_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Expected O, but got Unknown
//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0314: Unknown result type (might be due to invalid IL or missing references)
//IL_031b: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
if (!ev.User.IsAdmin)
{
return;
}
bool flag = default(bool);
if (ev.Message.Equals("!forgescheduler", StringComparison.OrdinalIgnoreCase))
{
try
{
ConfigFile.Reload();
ConfigFile.Save();
RaidForgeScheduleManager.Initialize(ConfigFile, Logger);
VExtensions.SendSystemMessage(ev.User, "<color=#00FF00>ForgeScheduler config reloaded successfully.</color>");
}
catch (Exception ex)
{
VExtensions.SendSystemMessage(ev.User, "<color=#FF0000>Failed to reload ForgeScheduler config:</color> " + ex.Message);
ManualLogSource logger = Logger;
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ForgeScheduler] Reload error => ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
logger.LogError(val);
}
}
if (ev.Message.Equals("!rfdayscount", StringComparison.OrdinalIgnoreCase))
{
string startDate = StartDateManager.GetStartDate();
if (string.IsNullOrWhiteSpace(startDate))
{
VExtensions.SendSystemMessage(ev.User, "<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>No StartDate set. Use '.startdate now' or '.startdate yyyy-MM-dd HH:mm:ss'.</color>");
return;
}
if (!DateTime.TryParseExact(startDate, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
{
VExtensions.SendSystemMessage(ev.User, "<color=#FFD700>[ForgeScheduler]</color> <color=#FF0000>Invalid StartDate '" + startDate + "' in config!</color>");
return;
}
DateTime now = DateTime.Now;
double totalDays = (now - result).TotalDays;
int num = (int)Math.Floor(totalDays);
if (num < 0)
{
num = 0;
}
DateTime dateTime = result.AddDays(num + 1);
TimeSpan timeSpan = dateTime - now;
if (timeSpan < TimeSpan.Zero)
{
timeSpan = TimeSpan.Zero;
}
string text = $"<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>Days passed since StartDate: <b>{num}</b>\nTime until day <b>{num + 1}</b>: {timeSpan:hh\\:mm\\:ss}</color>";
VExtensions.SendSystemMessage(ev.User, text);
}
if (!ev.Message.Equals("!rfdayreset", StringComparison.OrdinalIgnoreCase))
{
return;
}
try
{
ConfigFile.Reload();
ConfigFile.Save();
StartDateManager.Reload();
RaidForgeScheduleManager.Initialize(ConfigFile, Logger);
RaidForgeScheduleManager.ResetLastGolemDay();
RaidForgeScheduleManager.OnSchedulerUpdate();
int currentDayCount = RaidForgeScheduleManager.GetCurrentDayCount();
VExtensions.SendSystemMessage(ev.User, $"<color=#FFD700>Day count was reset and re-checked.</color> New day count: <color=#FFFFFF>{currentDayCount}</color>");
}
catch (Exception ex2)
{
VExtensions.SendSystemMessage(ev.User, "<color=#FF0000>Error resetting day count!</color> " + ex2.Message);
ManualLogSource logger2 = Logger;
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(38, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ForgeScheduler] !rfdayreset error => ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex2);
}
logger2.LogError(val);
}
}
}
public static class RaidForgeScheduleManager
{
private static bool _initialized;
public static ConfigEntry<bool> IgnoreScheduleTime;
private static ConfigEntry<string> MondayStart;
private static ConfigEntry<string> MondayEnd;
private static ConfigEntry<string> TuesdayStart;
private static ConfigEntry<string> TuesdayEnd;
private static ConfigEntry<string> WednesdayStart;
private static ConfigEntry<string> WednesdayEnd;
private static ConfigEntry<string> ThursdayStart;
private static ConfigEntry<string> ThursdayEnd;
private static ConfigEntry<string> FridayStart;
private static ConfigEntry<string> FridayEnd;
private static ConfigEntry<string> SaturdayStart;
private static ConfigEntry<string> SaturdayEnd;
private static ConfigEntry<string> SundayStart;
private static ConfigEntry<string> SundayEnd;
private static Dictionary<DayOfWeek, (TimeSpan start, TimeSpan end)> _windows = new Dictionary<DayOfWeek, (TimeSpan, TimeSpan)>();
private static ConfigEntry<bool> GolemAutomationEnabled;
private static ConfigEntry<string> GolemDayToHealthMap;
private static int _lastGolemDay = -1;
private static bool _lastRaidOn = false;
private static ManualLogSource _logger;
public static event Action<string> GolemHPUpdated;
public static void Initialize(ConfigFile config, ManualLogSource logger)
{
_logger = logger;
if (!_initialized)
{
_initialized = true;
}
IgnoreScheduleTime = config.Bind<bool>("RaidForgeAutomation", "IgnoreScheduleTime", false, "");
GolemAutomationEnabled = config.Bind<bool>("RaidForgeAutomation", "GolemAutomationEnabled", false, "");
GolemDayToHealthMap = config.Bind<string>("RaidForgeAutomation", "GolemDayToHealthMap", "0=Low,1=Normal,2=High,3=VeryHigh", "");
MondayStart = config.Bind<string>("RaidForgeAutomation", "MondayStart", "20:00:00", "");
MondayEnd = config.Bind<string>("RaidForgeAutomation", "MondayEnd", "22:00:00", "");
TuesdayStart = config.Bind<string>("RaidForgeAutomation", "TuesdayStart", "20:00:00", "");
TuesdayEnd = config.Bind<string>("RaidForgeAutomation", "TuesdayEnd", "22:00:00", "");
WednesdayStart = config.Bind<string>("RaidForgeAutomation", "WednesdayStart", "20:00:00", "");
WednesdayEnd = config.Bind<string>("RaidForgeAutomation", "WednesdayEnd", "22:00:00", "");
ThursdayStart = config.Bind<string>("RaidForgeAutomation", "ThursdayStart", "20:00:00", "");
ThursdayEnd = config.Bind<string>("RaidForgeAutomation", "ThursdayEnd", "22:00:00", "");
FridayStart = config.Bind<string>("RaidForgeAutomation", "FridayStart", "20:00:00", "");
FridayEnd = config.Bind<string>("RaidForgeAutomation", "FridayEnd", "22:00:00", "");
SaturdayStart = config.Bind<string>("RaidForgeAutomation", "SaturdayStart", "20:00:00", "");
SaturdayEnd = config.Bind<string>("RaidForgeAutomation", "SaturdayEnd", "22:00:00", "");
SundayStart = config.Bind<string>("RaidForgeAutomation", "SundayStart", "20:00:00", "");
SundayEnd = config.Bind<string>("RaidForgeAutomation", "SundayEnd", "22:00:00", "");
ReloadWindows();
}
public static void OnSchedulerUpdate()
{
CheckRaidWindow();
CheckGolemAutomation();
}
private static void ReloadWindows()
{
_windows.Clear();
ParseDay(DayOfWeek.Monday, MondayStart.Value, MondayEnd.Value);
ParseDay(DayOfWeek.Tuesday, TuesdayStart.Value, TuesdayEnd.Value);
ParseDay(DayOfWeek.Wednesday, WednesdayStart.Value, WednesdayEnd.Value);
ParseDay(DayOfWeek.Thursday, ThursdayStart.Value, ThursdayEnd.Value);
ParseDay(DayOfWeek.Friday, FridayStart.Value, FridayEnd.Value);
ParseDay(DayOfWeek.Saturday, SaturdayStart.Value, SaturdayEnd.Value);
ParseDay(DayOfWeek.Sunday, SundayStart.Value, SundayEnd.Value);
}
private static void ParseDay(DayOfWeek day, string startStr, string endStr)
{
if (TimeSpan.TryParse(startStr, out var result) && TimeSpan.TryParse(endStr, out var result2) && (!(result == TimeSpan.Zero) || !(result2 == TimeSpan.Zero)))
{
if (result2 == TimeSpan.Zero && result != TimeSpan.Zero)
{
result2 = new TimeSpan(24, 0, 0);
}
_windows[day] = (result, result2);
}
}
private static void CheckRaidWindow()
{
if (!IgnoreScheduleTime.Value)
{
DateTime now = DateTime.Now;
bool flag = false;
if (_windows.TryGetValue(now.DayOfWeek, out (TimeSpan, TimeSpan) value) && now.TimeOfDay >= value.Item1 && now.TimeOfDay <= value.Item2)
{
flag = true;
}
if (flag && !_lastRaidOn)
{
VrisingRaidToggler.EnableRaids(_logger);
_lastRaidOn = true;
}
else if (!flag && _lastRaidOn)
{
VrisingRaidToggler.DisableRaids(_logger);
_lastRaidOn = false;
}
}
}
private static void CheckGolemAutomation()
{
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d2: Expected O, but got Unknown
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
if (!GolemAutomationEnabled.Value)
{
return;
}
string startDate = StartDateManager.GetStartDate();
if (string.IsNullOrWhiteSpace(startDate) || !DateTime.TryParseExact(startDate, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
{
return;
}
DateTime now = DateTime.Now;
int num = (int)Math.Floor((now - result).TotalDays);
if (num < 0)
{
num = 0;
}
if (num == _lastGolemDay)
{
return;
}
_lastGolemDay = num;
string[] array = GolemDayToHealthMap.Value.Split(',', StringSplitOptions.RemoveEmptyEntries);
Dictionary<int, SiegeWeaponHealth> dictionary = new Dictionary<int, SiegeWeaponHealth>();
int num2 = -1;
string[] array2 = array;
foreach (string text in array2)
{
int num3 = text.IndexOf('=');
if (num3 < 0)
{
continue;
}
string s = text.Substring(0, num3).Trim();
string text2 = text;
int num4 = num3 + 1;
string value = text2.Substring(num4, text2.Length - num4).Trim();
if (int.TryParse(s, out var result2) && Enum.TryParse<SiegeWeaponHealth>(value, out SiegeWeaponHealth result3))
{
dictionary[result2] = result3;
if (result2 > num2)
{
num2 = result2;
}
}
}
SiegeWeaponHealth val = (SiegeWeaponHealth)2;
if (dictionary.TryGetValue(num, out var value2))
{
val = value2;
}
else if (num > num2 && num2 >= 0)
{
val = dictionary[num2];
}
if (SiegeWeaponManager.SetSiegeWeaponHealth(val, _logger))
{
ManualLogSource logger = _logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(48, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[ForgeScheduler] GolemAutomation => Day ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", HP => ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<SiegeWeaponHealth>(val);
}
logger.LogInfo(val2);
}
RaidForgeScheduleManager.GolemHPUpdated?.Invoke($"Day_{num}");
}
public static int GetCurrentDayCount()
{
string startDate = StartDateManager.GetStartDate();
if (string.IsNullOrWhiteSpace(startDate))
{
return -1;
}
if (!DateTime.TryParseExact(startDate, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
{
return -1;
}
DateTime now = DateTime.Now;
int num = (int)Math.Floor((now - result).TotalDays);
return (num >= 0) ? num : 0;
}
public static void ResetLastGolemDay()
{
_lastGolemDay = -9999;
}
public static DateTime? GetNextOnTime(int daysToSearch)
{
if (IgnoreScheduleTime.Value)
{
return null;
}
if (_windows == null || _windows.Count == 0)
{
return null;
}
DateTime now = DateTime.Now;
for (int i = 0; i < daysToSearch; i++)
{
DateTime dateTime = now.Date.AddDays(i);
if (_windows.TryGetValue(dateTime.DayOfWeek, out (TimeSpan, TimeSpan) value))
{
DateTime dateTime2 = dateTime + value.Item1;
if (dateTime2 > now)
{
return dateTime2;
}
}
}
return null;
}
}
public static class StartDateManager
{
private static bool _initialized;
private static ConfigFile _configFile;
private static ConfigEntry<string> _serverStartDate;
public static void Initialize()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
if (!_initialized)
{
_initialized = true;
string text = Path.Combine(Paths.ConfigPath, "ForgeScheduler");
Directory.CreateDirectory(text);
string text2 = Path.Combine(text, "StartDate.cfg");
_configFile = new ConfigFile(text2, true);
_serverStartDate = _configFile.Bind<string>("ServerStart", "StartDate", "", "Server start date/time in 'Example 2025-03-20 16:06:00 (yyyy-MM-dd HH:mm:ss)' format.");
}
}
public static void Reload()
{
if (_configFile != null)
{
_configFile.Reload();
_configFile.Save();
}
}
public static void SetStartDate(string dateStr)
{
if (_serverStartDate != null)
{
_serverStartDate.Value = dateStr;
ConfigFile configFile = _configFile;
if (configFile != null)
{
configFile.Save();
}
}
}
public static string GetStartDate()
{
return _serverStartDate?.Value ?? "";
}
[Command("startdate", "Sets or displays the server start date/time. Usage: .startdate now or .startdate yyyy-MM-dd HH:mm:ss", null, null, null, true)]
public static void StartDateCommand(ChatCommandContext ctx, string optionalDateStr = "")
{
DateTime result;
if (string.IsNullOrWhiteSpace(optionalDateStr))
{
string startDate = GetStartDate();
if (string.IsNullOrEmpty(startDate))
{
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>No start date set. Try '.startdate now' or '.startdate 2025-03-20 14:30:00'</color>");
}
else
{
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>Current start date: " + startDate + "</color>");
}
}
else if (optionalDateStr.Equals("now", StringComparison.OrdinalIgnoreCase))
{
string text = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
SetStartDate(text);
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>Start date set to " + text + "</color>");
}
else if (DateTime.TryParse(optionalDateStr, out result))
{
string text2 = result.ToString("yyyy-MM-dd HH:mm:ss");
SetStartDate(text2);
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>Start date set to " + text2 + "</color>");
}
else
{
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FF0000>Invalid date/time format! Use 'yyyy-MM-dd HH:mm:ss' or 'now'.</color>");
}
}
[Command("startdatecheck", "Displays the start date/time.", null, null, null, false)]
public static void StartDateCheckCommand(ChatCommandContext ctx)
{
string startDate = GetStartDate();
if (string.IsNullOrEmpty(startDate))
{
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>No start date set.</color>");
}
else
{
ctx.Reply("<color=#FFD700>[ForgeScheduler]</color> <color=#FFFFFF>Current start date: " + startDate + "</color>");
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "ForgeScheduler";
public const string PLUGIN_NAME = "ForgeScheduler";
public const string PLUGIN_VERSION = "0.1.10";
}
}
