using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BaseRaidTimer.Configuration;
using BaseRaidTimer.Localization;
using BaseRaidTimer.Runtime;
using BaseRaidTimer.UI;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Fusion;
using HarmonyLib;
using ModSettingsMenu.Api;
using SunkenlandLocalizationAPI.Api;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BaseRaidTimer")]
[assembly: AssemblyDescription("Base raid countdown timer mod for Sunkenland by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("BaseRaidTimer")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: ComVisible(false)]
[assembly: Guid("6d68fc4b-c0c5-4663-a743-f2da4e5a1268")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.1.0")]
namespace BaseRaidTimer
{
[BepInPlugin("IceBoxStudio.Sunkenland.BaseRaidTimer", "BaseRaidTimer", "1.0.1")]
[BepInDependency("IceBoxStudio.Sunkenland.ModSettingsMenu", "1.2.0")]
[BepInDependency("IceBoxStudio.Sunkenland.LocalizationAPI", "1.1.0")]
public sealed class BaseRaidTimer : BaseUnityPlugin
{
private Harmony _harmony;
internal static ManualLogSource Log { get; private set; }
private void Awake()
{
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
LocalizationApi.LanguageChanged += OnLanguageChanged;
try
{
Log.LogInfo((object)"=============================================");
Log.LogInfo((object)("BaseRaidTimer " + I18n.Text("plugin.initializing")));
Log.LogInfo((object)(I18n.Text("plugin.author_prefix") + "Ice Box Studio(https://steamcommunity.com/id/ibox666/)"));
ConfigManager.Bind(((BaseUnityPlugin)this).Config);
RegisterSettings();
_harmony = new Harmony("IceBoxStudio.Sunkenland.BaseRaidTimer");
_harmony.PatchAll(Assembly.GetExecutingAssembly());
Log.LogInfo((object)("BaseRaidTimer " + I18n.Text("plugin.initialized")));
Log.LogInfo((object)"=============================================");
}
catch (Exception arg)
{
Log.LogError((object)$"Failed to initialize Base Raid Timer: {arg}");
}
}
private static void RegisterSettings()
{
//IL_0005: 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)
//IL_0015: 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_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: 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_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
ModSettingsRegistry.Register("IceBoxStudio.Sunkenland.BaseRaidTimer", new ModSettingsModOptions
{
Name = "Base Raid Timer",
LocalizedName = () => I18n.Text("mod.name"),
Description = I18n.Text("mod.description"),
Author = "Ice Box Studio",
Version = "1.0.1",
NexusModsId = 81,
ThunderstoreTeam = "Ice_Box_Studio_Sunkenland",
ThunderstoreModName = "BaseRaidTimer"
});
}
private static void OnLanguageChanged(string language)
{
RegisterSettings();
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "IceBoxStudio.Sunkenland.BaseRaidTimer";
public const string PLUGIN_NAME = "BaseRaidTimer";
public const string PLUGIN_VERSION = "1.0.1";
}
}
namespace BaseRaidTimer.UI
{
internal static class RaidTimerDisplay
{
internal static void Append(TextMeshProUGUI timeText)
{
if (ConfigManager.Enabled && !((Object)(object)timeText == (Object)null) && RaidCountdown.TryGet(out var state, out var seconds))
{
((TMP_Text)timeText).enableWordWrapping = false;
((TMP_Text)timeText).text = ((TMP_Text)timeText).text + " | " + GetText(state, seconds);
}
}
private static string GetText(RaidState state, int seconds)
{
if (state == RaidState.HostDataUnavailable)
{
return I18n.Text("ui.raid.host_data_unavailable");
}
return I18n.Text("ui.raid.countdown", FormatTime(seconds));
}
private static string FormatTime(int totalSeconds)
{
int num = totalSeconds / 86400;
int num2 = totalSeconds / 3600 % 24;
int num3 = totalSeconds / 60 % 60;
int num4 = totalSeconds % 60;
if (num > 0)
{
return I18n.Text("ui.duration.days", num, num2, num3, num4);
}
return I18n.Text("ui.duration.time", num2, num3, num4);
}
}
}
namespace BaseRaidTimer.Runtime
{
internal enum RaidState
{
Countdown,
HostDataUnavailable
}
internal static class RaidCountdown
{
internal static bool TryGet(out RaidState state, out int seconds)
{
state = RaidState.Countdown;
seconds = 0;
GameLogics code = GameLogics.code;
Mainframe code2 = Mainframe.code;
if ((Object)(object)code == (Object)null || (Object)(object)code2 == (Object)null || (Object)(object)code2.Networking == (Object)null)
{
return false;
}
if (!code2.Networking.IsDedicatedServer && !code2.Networking.IsInSinglePlayerGameSession && !code2.Networking.IsServerAndInGameSession)
{
if (!RaidSync.TryGet(out var visible, out seconds))
{
state = RaidState.HostDataUnavailable;
return true;
}
state = RaidState.Countdown;
return visible;
}
return TryGetHost(code, out seconds);
}
internal static bool TryGetHost(GameLogics logic, out int seconds)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
seconds = 0;
Mainframe code = Mainframe.code;
if ((Object)(object)logic == (Object)null || (Object)(object)code == (Object)null || (Object)(object)code.WorldManager == (Object)null)
{
return false;
}
GlobalData globalData = code.GlobalData;
if ((Object)(object)globalData == (Object)null || (Object)(object)((SimulationBehaviour)globalData).Object == (Object)null)
{
return false;
}
if ((int)code.WorldManager.EnemyRaidDifficulty == 0 && !logic.SlaverAttacking)
{
return false;
}
if (globalData.GameTime <= 1 && !logic.SlaverAttacking)
{
return false;
}
if (float.IsNaN(logic.nextSiegeTime) || float.IsInfinity(logic.nextSiegeTime))
{
return false;
}
seconds = Mathf.Max(0, Mathf.FloorToInt(logic.nextSiegeTime));
return true;
}
}
internal static class RaidSync
{
private enum MessageType : byte
{
Hello,
Hidden,
Countdown
}
private const int PacketSize = 12;
private const byte ProtocolVersion = 1;
private const float StateTimeout = 5f;
private const float RequestInterval = 2f;
private const int MaxRequests = 3;
private static readonly HashSet<PlayerRef> Clients = new HashSet<PlayerRef>();
private static NetworkRunner _runner;
private static FusionCallbacksHandler _callbacks;
private static bool _hasState;
private static bool _visible;
private static int _seconds;
private static float _receivedAt;
private static float _lastRequestAt = -2f;
private static int _requestCount;
internal static void Bind()
{
//IL_0024: 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_003b: 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_005f: 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_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Expected O, but got Unknown
NetworkRunner runner = GetRunner();
if (_runner == runner)
{
return;
}
Unbind();
if (!((Object)(object)runner == (Object)null))
{
_runner = runner;
_callbacks = new FusionCallbacksHandler
{
PlayerLeft = OnPlayerLeft,
Shutdown = OnShutdown,
DisconnectedFromServer = OnDisconnected,
HostMigration = OnHostMigration,
ReliableDataReceived = OnData,
SceneLoadStart = OnSceneLoadStart
};
runner.AddCallbacks((INetworkRunnerCallbacks[])(object)new INetworkRunnerCallbacks[1] { (INetworkRunnerCallbacks)_callbacks });
if (runner.IsClient && !runner.IsServer)
{
Request(runner, force: true);
}
}
}
internal static void Tick(GameLogics logic)
{
Bind();
NetworkRunner runner = _runner;
if (!((Object)(object)runner == (Object)null))
{
if (runner.IsServer)
{
Broadcast(runner, logic);
}
else if (runner.IsClient && !IsFresh())
{
Request(runner, force: false);
}
}
}
internal static bool TryGet(out bool visible, out int seconds)
{
visible = false;
seconds = 0;
if (!IsFresh())
{
return false;
}
visible = _visible;
seconds = _seconds;
return true;
}
internal static bool IsPacket(ArraySegment<byte> data)
{
byte[] array = data.Array;
if (array == null || data.Count < 4)
{
return false;
}
int offset = data.Offset;
if (array[offset] == 66 && array[offset + 1] == 82 && array[offset + 2] == 84)
{
return array[offset + 3] == 83;
}
return false;
}
private static NetworkRunner GetRunner()
{
Mainframe code = Mainframe.code;
if ((Object)(object)code == (Object)null || (Object)(object)code.Networking == (Object)null)
{
return null;
}
return code.Networking.CurrentRunner;
}
private static void Broadcast(NetworkRunner runner, GameLogics logic)
{
//IL_0023: 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_0029: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
if (Clients.Count == 0)
{
return;
}
byte[] array = CreateState(logic);
foreach (PlayerRef activePlayer in runner.ActivePlayers)
{
if (activePlayer != runner.LocalPlayer && Clients.Contains(activePlayer))
{
runner.SendReliableDataToPlayer(activePlayer, array);
}
}
}
private static void SendState(NetworkRunner runner, PlayerRef player)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: 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)
if (!(player == runner.LocalPlayer))
{
runner.SendReliableDataToPlayer(player, CreateState(GameLogics.code));
}
}
private static byte[] CreateState(GameLogics logic)
{
if (!RaidCountdown.TryGetHost(logic, out var seconds))
{
return CreatePacket(MessageType.Hidden, 0);
}
return CreatePacket(MessageType.Countdown, seconds);
}
private static void Request(NetworkRunner runner, bool force)
{
float time = Time.time;
if (force || (_requestCount < 3 && !(time - _lastRequestAt < 2f)))
{
runner.SendReliableDataToServer(CreatePacket(MessageType.Hello, 0));
_lastRequestAt = time;
_requestCount++;
}
}
private static void OnData(NetworkRunner runner, PlayerRef player, ArraySegment<byte> data)
{
//IL_0025: 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)
if (runner != _runner || !TryRead(data, out var type, out var seconds))
{
return;
}
if (runner.IsServer)
{
if (type == MessageType.Hello && Clients.Add(player))
{
SendState(runner, player);
}
}
else if (runner.IsClient && type != MessageType.Hello)
{
_hasState = true;
_visible = type == MessageType.Countdown;
_seconds = (_visible ? seconds : 0);
_receivedAt = Time.time;
_requestCount = 0;
}
}
private static void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (runner == _runner && runner.IsServer)
{
Clients.Remove(player);
}
}
private static void OnShutdown(NetworkRunner runner, ShutdownReason reason)
{
Drop(runner);
}
private static void OnDisconnected(NetworkRunner runner)
{
Drop(runner);
}
private static void OnHostMigration(NetworkRunner runner, HostMigrationToken token)
{
if (runner == _runner)
{
Reset();
}
}
private static void OnSceneLoadStart(NetworkRunner runner)
{
if (runner == _runner)
{
ClearState();
_lastRequestAt = -2f;
_requestCount = 0;
}
}
private static bool IsFresh()
{
if (_hasState)
{
return Time.time - _receivedAt <= 5f;
}
return false;
}
private static bool TryRead(ArraySegment<byte> data, out MessageType type, out int seconds)
{
type = MessageType.Hello;
seconds = 0;
if (data.Count != 12 || !IsPacket(data))
{
return false;
}
byte[] array = data.Array;
int offset = data.Offset;
if (array[offset + 4] != 1)
{
return false;
}
type = (MessageType)array[offset + 5];
if (type != MessageType.Hello && type != MessageType.Hidden && type != MessageType.Countdown)
{
return false;
}
seconds = array[offset + 8] | (array[offset + 9] << 8) | (array[offset + 10] << 16) | (array[offset + 11] << 24);
if (type == MessageType.Countdown)
{
return seconds >= 0;
}
return true;
}
private static byte[] CreatePacket(MessageType type, int seconds)
{
return new byte[12]
{
66,
82,
84,
83,
1,
(byte)type,
0,
0,
(byte)seconds,
(byte)(seconds >> 8),
(byte)(seconds >> 16),
(byte)(seconds >> 24)
};
}
private static void Unbind()
{
NetworkRunner runner = _runner;
FusionCallbacksHandler callbacks = _callbacks;
_runner = null;
_callbacks = null;
Reset();
if ((Object)(object)runner != (Object)null && callbacks != null)
{
runner.RemoveCallbacks((INetworkRunnerCallbacks[])(object)new INetworkRunnerCallbacks[1] { (INetworkRunnerCallbacks)callbacks });
}
}
private static void Drop(NetworkRunner runner)
{
if (runner == _runner)
{
_runner = null;
_callbacks = null;
Reset();
}
}
private static void Reset()
{
Clients.Clear();
ClearState();
_lastRequestAt = -2f;
_requestCount = 0;
}
private static void ClearState()
{
_hasState = false;
_visible = false;
_seconds = 0;
_receivedAt = 0f;
}
}
}
namespace BaseRaidTimer.Patches
{
[HarmonyPatch(typeof(GameLogics), "CS")]
internal static class GameLogicsCsPatch
{
private static void Postfix(GameLogics __instance)
{
RaidSync.Tick(__instance);
}
}
[HarmonyPatch(typeof(GameLogics), "Start")]
internal static class GameLogicsStartPatch
{
private static void Postfix()
{
RaidSync.Bind();
}
}
[HarmonyPatch(typeof(NetworkRunnerCallbackManager), "OnReliableDataReceived", new Type[]
{
typeof(NetworkRunner),
typeof(PlayerRef),
typeof(ArraySegment<byte>)
})]
internal static class ReliableDataLogPatch
{
private static bool Prefix(ArraySegment<byte> data)
{
return !RaidSync.IsPacket(data);
}
}
[HarmonyPatch(typeof(UICombat), "Update")]
internal static class UICombatUpdatePatch
{
private static void Postfix(TextMeshProUGUI ___tmpHour)
{
RaidTimerDisplay.Append(___tmpHour);
}
}
}
namespace BaseRaidTimer.Localization
{
internal static class I18n
{
private const string FileName = "BaseRaidTimer.Localization.json";
private static readonly ModLocalizer _localizer = Load();
internal static ModLocalizer Localizer => _localizer;
internal static string Text(string key, params object[] args)
{
return _localizer.GetLocalizedText(key, args);
}
private static ModLocalizer Load()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
ModLocalizer obj = LocalizationApi.For("IceBoxStudio.Sunkenland.BaseRaidTimer");
obj.RegisterJson(Path.Combine(directoryName, "BaseRaidTimer.Localization.json"));
return obj;
}
}
}
namespace BaseRaidTimer.Configuration
{
internal static class ConfigManager
{
private const string Section = "Base Raid Timer";
private static ConfigEntry<bool> _enabled;
internal static bool Enabled
{
get
{
if (_enabled != null)
{
return _enabled.Value;
}
return true;
}
}
internal static void Bind(ConfigFile config)
{
_enabled = config.Bind<bool>("Base Raid Timer", "Enabled", true, I18n.Localizer.Config("config.enabled", 10, "Base Raid Timer", "config.section", 10, (AcceptableValueBase)null));
}
}
}
