using System;
using System.Collections.Generic;
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 System.Text;
using System.Text.Json;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Bloodstone.API;
using Bloody.Core;
using Bloody.Core.API.v1;
using Bloody.Core.GameData.v1;
using Bloody.Core.Helper.v1;
using Bloody.Core.Models.v1;
using Bloody.Core.Models.v1.Base;
using BloodyNotify.AutoAnnouncer;
using BloodyNotify.AutoAnnouncer.Models;
using BloodyNotify.AutoAnnouncer.Parser;
using BloodyNotify.DB;
using BloodyNotify.Systems;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using ProjectM;
using ProjectM.Network;
using Stunlock.Network;
using Unity.Collections;
using Unity.Entities;
using VampireCommandFramework;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BloodyNotify")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Add functionality to the server to have MOTD, Auto Announcer, when a user is online, when a user goes offline or when someone kills a VBlood in v rising.")]
[assembly: AssemblyFileVersion("3.0.10.0")]
[assembly: AssemblyInformationalVersion("3.0.10+1.Branch.master.Sha.ce2ad103a4f69831f7bc950d8ac7a303ae4bc750")]
[assembly: AssemblyProduct("BloodyNotify")]
[assembly: AssemblyTitle("BloodyNotify")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.0.10.0")]
[module: UnverifiableCode]
namespace BloodyNotify
{
[BepInPlugin("BloodyNotify", "BloodyNotify", "3.0.10")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[Reloadable]
public class Plugin : BasePlugin, IRunOnInitialized
{
private Harmony _harmony;
public static Logger Logger;
public static SystemsCore SystemsCore;
public static ConfigEntry<bool> AnnounceOnline;
public static ConfigEntry<bool> AnnounceeOffline;
public static ConfigEntry<bool> AnnounceNewUser;
public static ConfigEntry<bool> AnnounceVBlood;
public static ConfigEntry<string> VBloodFinalConcatCharacters;
public static ConfigEntry<bool> AutoAnnouncerConfig;
public static ConfigEntry<int> IntervalAutoAnnouncer;
public static ConfigEntry<bool> MessageOfTheDay;
public static readonly string ConfigPath = Path.Combine(Paths.ConfigPath, "BloodyNotify");
public override void Load()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
Logger = new Logger(((BasePlugin)this).Log);
if (!Core.IsServer)
{
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(27, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("BloodyNotify");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is only for server!");
}
log.LogInfo(val);
}
else
{
_harmony = new Harmony("BloodyNotify");
CommandRegistry.RegisterAll();
EventsHandlerSystem.OnInitialize += new OnGameDataInitializedEventHandler(GameDataOnInitialize);
InitConfig();
LoadDatabase.LoadAllConfig();
Logger.LogInfo("Plugin BloodyNotify version 3.0.10 is loaded!");
}
}
private void GameDataOnInitialize(World world)
{
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Expected O, but got Unknown
SystemsCore = Core.SystemsCore;
Database.EnabledFeatures[NotifyFeature.online] = AnnounceOnline.Value;
Database.EnabledFeatures[NotifyFeature.offline] = AnnounceeOffline.Value;
Database.EnabledFeatures[NotifyFeature.newuser] = AnnounceNewUser.Value;
Database.EnabledFeatures[NotifyFeature.vblood] = AnnounceVBlood.Value;
Database.EnabledFeatures[NotifyFeature.auto] = AutoAnnouncerConfig.Value;
Database.EnabledFeatures[NotifyFeature.motd] = MessageOfTheDay.Value;
Database.setVBloodFinalConcatCharacters(VBloodFinalConcatCharacters.Value);
Database.setIntervalAutoAnnouncer(IntervalAutoAnnouncer.Value);
EventsHandlerSystem.OnUserConnected += new OnUserConnectedEventHandler(OnlineOfflineSystem.OnUserOnline);
EventsHandlerSystem.OnUserDisconnected += new OnUserDisconnectedEventHandler(OnlineOfflineSystem.OnUserOffline);
EventsHandlerSystem.OnDeathVBlood += new DeathVbloodEventHandler(KillVBloodSystem.OnDetahVblood);
AutoAnnouncerFunction.StartAutoAnnouncer();
}
private void InitConfig()
{
AnnounceOnline = ((BasePlugin)this).Config.Bind<bool>("UserOnline", "enabled", true, "Enable Announce when user online");
AnnounceeOffline = ((BasePlugin)this).Config.Bind<bool>("UserOffline", "enabled", true, "Enable Announce when user offline");
AnnounceNewUser = ((BasePlugin)this).Config.Bind<bool>("NewUserOnline", "enabled", true, "Enable Announce when new user create in server");
AnnounceVBlood = ((BasePlugin)this).Config.Bind<bool>("AnnounceVBlood", "enabled", true, "Enable Announce when user/users kill a VBlood Boss.");
VBloodFinalConcatCharacters = ((BasePlugin)this).Config.Bind<string>("AnnounceVBlood", "VBloodFinalConcatCharacters", "and", "Final string for concat two or more players kill a VBlood Boss.");
AutoAnnouncerConfig = ((BasePlugin)this).Config.Bind<bool>("AutoAnnouncer", "enabled", false, "Enable AutoAnnouncer.");
IntervalAutoAnnouncer = ((BasePlugin)this).Config.Bind<int>("AutoAnnouncer", "interval", 300, "Interval seconds for spam AutoAnnouncer.");
MessageOfTheDay = ((BasePlugin)this).Config.Bind<bool>("MessageOfTheDay", "enabled", false, "Enable Message Of The Day.");
if (!Directory.Exists(ConfigPath))
{
Directory.CreateDirectory(ConfigPath);
}
Config.CheckAndCreateConfigs();
}
public void OnGameInitialized()
{
}
public override bool Unload()
{
CommandRegistry.UnregisterAssembly();
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
return true;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "BloodyNotify";
public const string PLUGIN_NAME = "BloodyNotify";
public const string PLUGIN_VERSION = "3.0.10";
}
}
namespace BloodyNotify.Systems
{
internal class KillVBloodSystem
{
private const double SendMessageDelay = 2.0;
public static Dictionary<string, HashSet<string>> vbloodKills = new Dictionary<string, HashSet<string>>();
private static EntityManager _entityManager = Plugin.SystemsCore.EntityManager;
private static PrefabCollectionSystem _prefabCollectionSystem = Plugin.SystemsCore.PrefabCollectionSystem;
private static bool checkKiller = false;
private static Dictionary<string, DateTime> lastKillerUpdate = new Dictionary<string, DateTime>();
public static void OnDetahVblood(VBloodSystem sender, NativeList<VBloodConsumed> deathEvents)
{
//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)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: 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)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: 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_0052: 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_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
if (!Database.EnabledFeatures[NotifyFeature.vblood])
{
return;
}
if (deathEvents.Length > 0)
{
Enumerator<VBloodConsumed> enumerator = deathEvents.GetEnumerator();
while (enumerator.MoveNext())
{
VBloodConsumed current = enumerator.Current;
if (((EntityManager)(ref _entityManager)).HasComponent<PlayerCharacter>(current.Target))
{
PlayerCharacter componentData = ((EntityManager)(ref _entityManager)).GetComponentData<PlayerCharacter>(current.Target);
User componentData2 = ((EntityManager)(ref _entityManager)).GetComponentData<User>(componentData.UserEntity);
string text = _prefabCollectionSystem.PrefabGuidToNameDictionary[current.Source];
AddKiller(text.ToString(), ((object)(FixedString64Bytes)(ref componentData2.CharacterName)).ToString());
lastKillerUpdate[text.ToString()] = DateTime.Now;
checkKiller = true;
}
}
}
else
{
if (!checkKiller)
{
return;
}
bool flag = false;
foreach (KeyValuePair<string, DateTime> item in lastKillerUpdate)
{
DateTime value = item.Value;
if (DateTime.Now - value < TimeSpan.FromSeconds(2.0))
{
flag = true;
}
else
{
SendAnnouncementMessage(item.Key);
}
}
checkKiller = flag;
}
}
public static void AddKiller(string vblood, string killerCharacterName)
{
if (!vbloodKills.ContainsKey(vblood))
{
vbloodKills[vblood] = new HashSet<string>();
}
vbloodKills[vblood].Add(killerCharacterName);
}
public static void RemoveKillers(string vblood)
{
vbloodKills[vblood] = new HashSet<string>();
}
public static List<string> GetKillers(string vblood)
{
return vbloodKills[vblood].ToList();
}
public static void SendAnnouncementMessage(string vblood)
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
if (checkifBloodyBoss(vblood))
{
RemoveKillers(vblood);
return;
}
string announcementMessage = GetAnnouncementMessage(vblood);
if (announcementMessage == "ignore")
{
RemoveKillers(vblood);
}
else
{
if (announcementMessage == null)
{
return;
}
foreach (UserModel item in GameData.Users.Online)
{
if (!Database.getVBloodNotifyIgnore(item.CharacterName))
{
ServerChatUtils.SendSystemMessageToClient(VWorld.Server.EntityManager, ((EntityModel)item).Internals.User.Value, announcementMessage);
}
}
RemoveKillers(vblood);
}
}
private static bool checkifBloodyBoss(string vblood)
{
//IL_0002: 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)
//IL_000a: 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)
//IL_0019: 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_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: 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_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
NativeArray<Entity> entitiesByComponentTypes = QueryComponents.GetEntitiesByComponentTypes<VBloodUnit, NameableInteractable, LifeTime>((EntityQueryOptions)0, false);
Enumerator<Entity> enumerator = entitiesByComponentTypes.GetEnumerator();
while (enumerator.MoveNext())
{
Entity current = enumerator.Current;
try
{
NpcModel val = GameData.Npcs.FromEntity(current);
if (!(_prefabCollectionSystem.PrefabGuidToNameDictionary[val.PrefabGUID] == vblood))
{
continue;
}
NameableInteractable val2 = ECSExtensions.Read<NameableInteractable>(current);
if (((FixedString64Bytes)(ref val2.Name)).Value.Contains("bb"))
{
if (ECSExtensions.Read<Health>(current).IsDead)
{
entitiesByComponentTypes.Dispose();
return true;
}
entitiesByComponentTypes.Dispose();
return false;
}
}
catch
{
}
}
entitiesByComponentTypes.Dispose();
return false;
}
public static string GetAnnouncementMessage(string vblood)
{
List<string> killers = GetKillers(vblood);
string prefabNameValue = Database.getPrefabNameValue(vblood);
bool prefabIgnoreValue = Database.getPrefabIgnoreValue(vblood);
StringBuilder stringBuilder = new StringBuilder();
if (prefabIgnoreValue)
{
return "ignore";
}
if (killers.Count == 0)
{
return null;
}
if (killers.Count == 1)
{
stringBuilder.Append(FontColorChatSystem.Yellow(killers[0]));
}
if (killers.Count == 2)
{
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder stringBuilder3 = stringBuilder2;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(2, 3, stringBuilder2);
handler.AppendFormatted(FontColorChatSystem.Yellow(killers[0]));
handler.AppendLiteral(" ");
handler.AppendFormatted(Database.getVBloodFinalConcatCharacters());
handler.AppendLiteral(" ");
handler.AppendFormatted(FontColorChatSystem.Yellow(killers[1]));
stringBuilder3.Append(ref handler);
}
if (killers.Count > 2)
{
for (int i = 0; i < killers.Count; i++)
{
if (i == killers.Count - 1)
{
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder stringBuilder4 = stringBuilder2;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(1, 2, stringBuilder2);
handler.AppendFormatted(Database.getVBloodFinalConcatCharacters());
handler.AppendLiteral(" ");
handler.AppendFormatted(FontColorChatSystem.Yellow(killers[i]));
stringBuilder4.Append(ref handler);
}
else
{
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder stringBuilder5 = stringBuilder2;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(2, 1, stringBuilder2);
handler.AppendFormatted(FontColorChatSystem.Yellow(killers[i]));
handler.AppendLiteral(", ");
stringBuilder5.Append(ref handler);
}
}
}
return FontColorChatSystem.Green(Database.getDefaultAnnounceValue("VBlood").Replace("#user#", $"{stringBuilder}").Replace("#vblood#", FontColorChatSystem.Red(prefabNameValue) ?? "") ?? "");
}
}
internal class OnlineOfflineSystem
{
private static EntityManager entityManager = Plugin.SystemsCore.EntityManager;
internal static void OnUserOnline(ServerBootstrapSystem sender, NetConnectionId netConnectionId)
{
//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_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_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: 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_0118: Unknown result type (might be due to invalid IL or missing references)
int num = sender._NetEndPointToApprovedUserIndex[netConnectionId];
Entity userEntity = ((Il2CppArrayBase<ServerClient>)(object)sender._ApprovedUsersLookup)[num].UserEntity;
UserModel val = GameData.Users.FromEntity(userEntity);
bool num2 = IsNewUser(userEntity);
string characterName = val.CharacterName;
Plugin.Logger.LogInfo("ha conectado " + val.CharacterName + " ");
if (!num2)
{
if (Database.EnabledFeatures[NotifyFeature.online])
{
string userOnlineValue = Database.getUserOnlineValue(characterName);
userOnlineValue = userOnlineValue.Replace("#user#", FontColorChatSystem.Yellow(characterName) ?? "");
ServerChatUtils.SendSystemMessageToAllClients(entityManager, FontColorChatSystem.Green(userOnlineValue ?? ""));
}
}
else if (Database.EnabledFeatures[NotifyFeature.newuser])
{
string userOnlineValue2 = Database.getUserOnlineValue("");
ServerChatUtils.SendSystemMessageToAllClients(entityManager, FontColorChatSystem.Green(userOnlineValue2 ?? ""));
}
if (!Database.EnabledFeatures[NotifyFeature.motd])
{
return;
}
foreach (string item in Database.getMessageOfTheDay())
{
string text = item.Replace("#user#", characterName ?? "");
ServerChatUtils.SendSystemMessageToClient(entityManager, ECSExtensions.Read<User>(userEntity), text);
}
}
internal static void OnUserOffline(ServerBootstrapSystem sender, NetConnectionId netConnectionId, ConnectionStatusChangeReason connectionStatusReason, string extraData)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
if (Database.EnabledFeatures[NotifyFeature.offline] && (int)connectionStatusReason != 17)
{
int num = sender._NetEndPointToApprovedUserIndex[netConnectionId];
Entity userEntity = ((Il2CppArrayBase<ServerClient>)(object)sender._ApprovedUsersLookup)[num].UserEntity;
string characterName = GameData.Users.FromEntity(userEntity).CharacterName;
string userOfflineValue = Database.getUserOfflineValue(characterName);
userOfflineValue = userOfflineValue.Replace("#user#", FontColorChatSystem.Yellow(characterName) ?? "");
ServerChatUtils.SendSystemMessageToAllClients(entityManager, userOfflineValue ?? "");
}
}
public static bool IsNewUser(Entity userEntity)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
User val = ECSExtensions.Read<User>(userEntity);
return ((FixedString64Bytes)(ref val.CharacterName)).IsEmpty;
}
}
}
namespace BloodyNotify.DB
{
internal class Config
{
public static readonly string ConfigPath = Plugin.ConfigPath;
public static string DefaultAutoAnnounceMessagesConfig = "[[\"Message 1 Line 1\",\"Message 1 Line 2\"],[\"Message 2 Line 1\",\"Message 2 Line 2\",\"Message 2 Line 3\",\"Message 2 Line 4\"]]";
public static Dictionary<string, string> DefaultAnnounceDictionary => new Dictionary<string, string>
{
{ "online", "#user# is online!" },
{ "offline", "#user# has gone offline!" },
{ "newUser", "Welcome to server" },
{ "VBlood", "Congratulations to #user# for beating #vblood#!" }
};
public static Dictionary<string, string> PrefabToNamesDefault => new Dictionary<string, string>
{
{ "CHAR_Bandit_Frostarrow_VBlood", "Keely the Frost Archer" },
{ "CHAR_Bandit_Foreman_VBlood", "Rufus the Foreman" },
{ "CHAR_Bandit_StoneBreaker_VBlood", "Errol the Stonebreaker" },
{ "CHAR_Bandit_Chaosarrow_VBlood", "Lidia the Chaos Archer" },
{ "CHAR_Undead_BishopOfDeath_VBlood", "Goreswine the Ravager" },
{ "CHAR_Bandit_Stalker_VBlood", "Grayson the Armourer" },
{ "CHAR_Vermin_DireRat_VBlood", "Putrid Rat" },
{ "CHAR_Bandit_Bomber_VBlood", "Clive the Firestarter" },
{ "CHAR_Undead_Priest_VBlood", "Nicholaus the Fallen" },
{ "CHAR_Bandit_Tourok_VBlood", "Quincey the Bandit King" },
{ "CHAR_Villager_Tailor_VBlood", "Beatrice the Tailor" },
{ "CHAR_Militia_Guard_VBlood", "Vincent the Frostbringer" },
{ "CHAR_VHunter_Leader_VBlood", "Tristan the Vampire Hunter" },
{ "CHAR_Undead_BishopOfShadows_VBlood", "Leandra the Shadow Priestess" },
{ "CHAR_Geomancer_Human_VBlood", "Terah the Geomancer" },
{ "CHAR_Militia_Longbowman_LightArrow_Vblood", "Meredith the Bright Archer" },
{ "CHAR_Wendigo_VBlood", "Frostmaw the Mountain Terror" },
{ "CHAR_Militia_Leader_VBlood", "Octavian the Militia Captain" },
{ "CHAR_Militia_BishopOfDunley_VBlood", "Raziel the Shepherd" },
{ "CHAR_Spider_Queen_VBlood", "Ungora the Spider Queen" },
{ "CHAR_Cursed_ToadKing_VBlood", "Albert the Duke of Balaton" },
{ "CHAR_VHunter_Jade_VBlood", "Jade the Vampire Hunter" },
{ "CHAR_Undead_ZealousCultist_VBlood", "Foulrot the Soultaker" },
{ "CHAR_WerewolfChieftain_VBlood", "Willfred the Werewolf Chief" },
{ "CHAR_ArchMage_VBlood", "Mairwyn the Elementalist" },
{ "CHAR_Winter_Yeti_VBlood", "Terrorclaw the Ogre" },
{ "CHAR_Harpy_Matriarch_VBlood", "Morian the Stormwing Matriarch" },
{ "CHAR_Cursed_Witch_VBlood", "Matka the Curse Weaver" },
{ "CHAR_BatVampire_VBlood", "Lord Styx the Night Champion" },
{ "CHAR_Cursed_MountainBeast_VBlood", "Gorecrusher the Behemoth" },
{ "CHAR_Manticore_VBlood", "Talzur the Winged Horror" },
{ "CHAR_Bandit_GraveDigger_VBlood_UNUSED", "Boris the Gravedigger" },
{ "CHAR_Bandit_Leader_VBlood_UNUSED", "Quincey the Marauder" },
{ "CHAR_Bandit_Miner_VBlood_UNUSED", "Errol the Stonebreaker" },
{ "CHAR_ChurchOfLight_Cardinal_VBlood", "Azariel the Sunbringer" },
{ "CHAR_ChurchOfLight_Overseer_VBlood", "Sir Magnus the Overseer" },
{ "CHAR_ChurchOfLight_Paladin_VBlood", "Solarus the Immaculate" },
{ "CHAR_ChurchOfLight_Sommelier_VBlood", "Baron du Bouchon the Sommelier" },
{ "CHAR_Forest_Bear_Dire_Vblood", "Kodia the Ferocious Bear" },
{ "CHAR_Forest_Wolf_VBlood", "Alpha the White Wolf" },
{ "CHAR_Gloomrot_Iva_VBlood", "Ziva the Engineer" },
{ "CHAR_Gloomrot_Monster_VBlood", "Adam the Firstborn" },
{ "CHAR_Gloomrot_Purifier_VBlood", "Angram the Purifier" },
{ "CHAR_Gloomrot_RailgunSergeant_VBlood", "Voltatia the Power Master" },
{ "CHAR_Gloomrot_TheProfessor_VBlood", "Henry Blackbrew the Doctor" },
{ "CHAR_Gloomrot_Voltage_VBlood", "Domina the Blade Dancer" },
{ "CHAR_Militia_Glassblower_VBlood", "Grethel the Glassblower" },
{ "CHAR_Militia_Hound_VBlood", "Brutus the Watcher" },
{ "CHAR_Militia_HoundMaster_VBlood", "Boyo" },
{ "CHAR_Militia_Nun_VBlood", "Christina the Sun Priestess" },
{ "CHAR_Militia_Scribe_VBlood", "Maja the Dark Savant" },
{ "CHAR_Poloma_VBlood", "Polora the Feywalker" },
{ "CHAR_Undead_CursedSmith_VBlood", "Cyril the Cursed Smith" },
{ "CHAR_Undead_Infiltrator_VBlood", "Bane the Shadowblade" },
{ "CHAR_Undead_Leader_Vblood", "Kriig the Undead General" },
{ "CHAR_Villager_CursedWanderer_VBlood", "Ben the Old Wanderer" },
{ "CHAR_Bandit_Fisherman_VBlood", "Finn the Fisherman" },
{ "CHAR_VHunter_CastleMan", "Simon Belmont the Vampire Hunter" },
{ "CHAR_Vampire_BloodKnight_VBlood", "General Valencia the Depraved" },
{ "CHAR_Vampire_Dracula_VBlood", "Dracula the Immortal King" },
{ "CHAR_Vampire_HighLord_VBlood", "General Cassius the Betrayer" },
{ "CHAR_Vampire_IceRanger_VBlood", "General Elena the Hollow" },
{ "NoPrefabName", "VBlood Boss" }
};
public static Dictionary<string, bool> PrefabsIgnoreDefaul => new Dictionary<string, bool>
{
{ "CHAR_Bandit_Frostarrow_VBlood", false },
{ "CHAR_Bandit_Foreman_VBlood", false },
{ "CHAR_Bandit_StoneBreaker_VBlood", false },
{ "CHAR_Bandit_Chaosarrow_VBlood", false },
{ "CHAR_Undead_BishopOfDeath_VBlood", false },
{ "CHAR_Bandit_Stalker_VBlood", false },
{ "CHAR_Vermin_DireRat_VBlood", false },
{ "CHAR_Bandit_Bomber_VBlood", false },
{ "CHAR_Undead_Priest_VBlood", false },
{ "CHAR_Bandit_Tourok_VBlood", false },
{ "CHAR_Villager_Tailor_VBlood", false },
{ "CHAR_Militia_Guard_VBlood", false },
{ "CHAR_VHunter_Leader_VBlood", false },
{ "CHAR_Undead_BishopOfShadows_VBlood", false },
{ "CHAR_Geomancer_Human_VBlood", false },
{ "CHAR_Militia_Longbowman_LightArrow_Vblood", false },
{ "CHAR_Wendigo_VBlood", false },
{ "CHAR_Militia_Leader_VBlood", false },
{ "CHAR_Militia_BishopOfDunley_VBlood", false },
{ "CHAR_Spider_Queen_VBlood", false },
{ "CHAR_Cursed_ToadKing_VBlood", false },
{ "CHAR_VHunter_Jade_VBlood", false },
{ "CHAR_Undead_ZealousCultist_VBlood", false },
{ "CHAR_WerewolfChieftain_VBlood", false },
{ "CHAR_ArchMage_VBlood", false },
{ "CHAR_Winter_Yeti_VBlood", false },
{ "CHAR_Harpy_Matriarch_VBlood", false },
{ "CHAR_Cursed_Witch_VBlood", false },
{ "CHAR_BatVampire_VBlood", false },
{ "CHAR_Cursed_MountainBeast_VBlood", false },
{ "CHAR_Manticore_VBlood", false },
{ "CHAR_Paladin_VBlood", false },
{ "CHAR_Bandit_GraveDigger_VBlood_UNUSED", false },
{ "CHAR_Bandit_Leader_VBlood_UNUSED", false },
{ "CHAR_Bandit_Miner_VBlood_UNUSED", false },
{ "CHAR_ChurchOfLight_Cardinal_VBlood", false },
{ "CHAR_ChurchOfLight_Overseer_VBlood", false },
{ "CHAR_ChurchOfLight_Sommelier_VBlood", false },
{ "CHAR_Forest_Bear_Dire_Vblood", false },
{ "CHAR_Forest_Wolf_VBlood", false },
{ "CHAR_Gloomrot_Iva_VBlood", false },
{ "CHAR_Gloomrot_Monster_VBlood", false },
{ "CHAR_Gloomrot_Purifier_VBlood", false },
{ "CHAR_Gloomrot_RailgunSergeant_VBlood", false },
{ "CHAR_Gloomrot_TheProfessor_VBlood", false },
{ "CHAR_Gloomrot_Voltage_VBlood", false },
{ "CHAR_Militia_Glassblower_VBlood", false },
{ "CHAR_Militia_Hound_VBlood", false },
{ "CHAR_Militia_HoundMaster_VBlood", false },
{ "CHAR_Militia_Nun_VBlood", false },
{ "CHAR_Militia_Scribe_VBlood", false },
{ "CHAR_Poloma_VBlood", false },
{ "CHAR_Undead_CursedSmith_VBlood", false },
{ "CHAR_Undead_Infiltrator_VBlood", false },
{ "CHAR_Undead_Leader_Vblood", false },
{ "CHAR_Villager_CursedWanderer_VBlood", false },
{ "CHAR_Bandit_Fisherman_VBlood", false },
{ "CHAR_VHunter_CastleMan", false },
{ "CHAR_Vampire_BloodKnight_VBlood", false },
{ "CHAR_Vampire_Dracula_VBlood", false },
{ "CHAR_Vampire_HighLord_VBlood", false },
{ "CHAR_Vampire_IceRanger_VBlood", false },
{ "NoPrefabName", false }
};
public static Dictionary<string, string> DefaultOnline => new Dictionary<string, string> { { "nick", "#user# is online!" } };
public static Dictionary<string, string> DefaultOffline => new Dictionary<string, string> { { "nick", "#user# is ofline!" } };
public static Dictionary<string, bool> DefaultVBloodAnnounceIgnoreUsers => new Dictionary<string, bool> { { "nick", true } };
public static List<string> DefaultMessageOfTheDay => new List<string> { "#user# this is Message of the day Line 1", "Message of the day Line 2", "Message of the day Line 3" };
public static void CreateDefaultNotificationTextConfig()
{
string contents = JsonSerializer.Serialize(DefaultAnnounceDictionary, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "default_announce.json"), contents);
}
public static void CreateOnlineDefaultConfig()
{
string contents = JsonSerializer.Serialize(DefaultOnline, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "users_online.json"), contents);
}
public static void CreateOfflineDefaultConfig()
{
string contents = JsonSerializer.Serialize(DefaultOffline, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "users_offline.json"), contents);
}
public static void CreateLocationVBloodDefaultConfig()
{
string contents = JsonSerializer.Serialize(PrefabToNamesDefault, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "prefabs_names.json"), contents);
}
public static void CreateIgnoreVBloodDefaultConfig()
{
string contents = JsonSerializer.Serialize(PrefabsIgnoreDefaul, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "prefabs_names_ignore.json"), contents);
}
public static void CreateVBloodNotifyIgnoreConfig()
{
string contents = JsonSerializer.Serialize(DefaultVBloodAnnounceIgnoreUsers, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "vbloodannounce_ignore_users.json"), contents);
}
public static void CreateAutoAnnouncerMessagesConfig()
{
File.WriteAllText(Path.Combine(ConfigPath, "auto_announcer_messages.json"), DefaultAutoAnnounceMessagesConfig);
}
public static void CreateMessagesOfTheDayConfig()
{
string contents = JsonSerializer.Serialize(DefaultMessageOfTheDay, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "message_of_the_day.json"), contents);
}
public static void CheckAndCreateConfigs()
{
if (!File.Exists(Path.Combine(ConfigPath, "users_online.json")))
{
CreateOnlineDefaultConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "users_offline.json")))
{
CreateOfflineDefaultConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "default_announce.json")))
{
CreateDefaultNotificationTextConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "prefabs_names.json")))
{
CreateLocationVBloodDefaultConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "prefabs_names_ignore.json")))
{
CreateIgnoreVBloodDefaultConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "vbloodannounce_ignore_users.json")))
{
CreateVBloodNotifyIgnoreConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "auto_announcer_messages.json")))
{
CreateAutoAnnouncerMessagesConfig();
}
if (!File.Exists(Path.Combine(ConfigPath, "message_of_the_day.json")))
{
CreateMessagesOfTheDayConfig();
}
}
}
internal class Database
{
private static string VBloodFinalConcatCharacters;
private static int IntervalAutoAnnouncer;
private static List<AutoAnnouncerMessage> AutoAnnouncerMessages;
private static List<string> MessageOfTheDay;
internal static Dictionary<NotifyFeature, bool> EnabledFeatures;
private static Dictionary<string, string> DefaultAnnounce { get; set; }
private static Dictionary<string, string> UsersConfigOnline { get; set; }
private static Dictionary<string, string> UsersConfigOffline { get; set; }
private static Dictionary<string, string> PrefabToNames { get; set; }
private static Dictionary<string, bool> PrefabsIgnore { get; set; }
private static Dictionary<string, bool> VBloodNotifyIgnore { get; set; }
static Database()
{
VBloodFinalConcatCharacters = "and";
IntervalAutoAnnouncer = 0;
AutoAnnouncerMessages = new List<AutoAnnouncerMessage>();
MessageOfTheDay = new List<string>();
DefaultAnnounce = new Dictionary<string, string>();
UsersConfigOnline = new Dictionary<string, string>();
UsersConfigOffline = new Dictionary<string, string>();
PrefabToNames = new Dictionary<string, string>();
PrefabsIgnore = new Dictionary<string, bool>();
VBloodNotifyIgnore = new Dictionary<string, bool>();
EnabledFeatures = new Dictionary<NotifyFeature, bool>();
setAllFeatures(isEnabled: false);
}
internal static void setAllFeatures(bool isEnabled)
{
foreach (NotifyFeature value in Enum.GetValues(typeof(NotifyFeature)))
{
EnabledFeatures[value] = isEnabled;
}
}
public static void setVBloodFinalConcatCharacters(string value)
{
VBloodFinalConcatCharacters = value;
}
public static string getVBloodFinalConcatCharacters()
{
return VBloodFinalConcatCharacters;
}
public static bool setDefaultAnnounce(Dictionary<string, string> value)
{
if (value == null)
{
return false;
}
DefaultAnnounce = value;
return true;
}
public static bool setUsersOnline(Dictionary<string, string> value)
{
if (value == null)
{
return false;
}
UsersConfigOnline = value;
return true;
}
public static bool setUsersOffline(Dictionary<string, string> value)
{
if (value == null)
{
return false;
}
UsersConfigOffline = value;
return true;
}
public static bool setPrefabsNames(Dictionary<string, string> value)
{
if (value == null)
{
return false;
}
PrefabToNames = value;
return true;
}
public static bool setPrefabsIgnore(Dictionary<string, bool> value)
{
if (value == null)
{
return false;
}
PrefabsIgnore = value;
return true;
}
public static bool setVBloodNotifyIgnore(Dictionary<string, bool> value)
{
if (value == null)
{
return false;
}
VBloodNotifyIgnore = value;
return true;
}
public static string getDefaultAnnounceValue(string value)
{
if (value == null)
{
return value;
}
if (DefaultAnnounce.ContainsKey(value))
{
return DefaultAnnounce[value];
}
return value;
}
public static string getUserOnlineValue(string user)
{
if (user == null || user == "")
{
return getDefaultAnnounceValue("newUser");
}
if (UsersConfigOnline.ContainsKey(user))
{
return UsersConfigOnline[user];
}
return getDefaultAnnounceValue("online");
}
public static string getUserOfflineValue(string user)
{
if (user == null || user == "")
{
return user;
}
if (UsersConfigOffline.ContainsKey(user))
{
return UsersConfigOffline[user];
}
return getDefaultAnnounceValue("offline");
}
public static string getPrefabNameValue(string prefabName)
{
if (prefabName == null)
{
return "NoPrefabName";
}
if (PrefabToNames.ContainsKey(prefabName))
{
return PrefabToNames[prefabName];
}
return PrefabToNames["NoPrefabName"];
}
public static bool getPrefabIgnoreValue(string prefabName)
{
if (prefabName == null)
{
return true;
}
if (PrefabsIgnore.ContainsKey(prefabName))
{
return PrefabsIgnore[prefabName];
}
return true;
}
public static bool getVBloodNotifyIgnore(string characterName)
{
if (characterName == null)
{
return false;
}
if (VBloodNotifyIgnore.ContainsKey(characterName))
{
return true;
}
return false;
}
public static bool addVBloodNotifyIgnore(string characterName)
{
if (VBloodNotifyIgnore.ContainsKey(characterName))
{
return true;
}
VBloodNotifyIgnore.Add(characterName, value: true);
SaveDatabase.SaveVBloodNotifyIgnoreConfig(VBloodNotifyIgnore);
return true;
}
public static bool removeVBloodNotifyIgnore(string characterName)
{
if (VBloodNotifyIgnore.ContainsKey(characterName))
{
VBloodNotifyIgnore.Remove(characterName);
SaveDatabase.SaveVBloodNotifyIgnoreConfig(VBloodNotifyIgnore);
return true;
}
return true;
}
public static int getIntervalAutoAnnouncer()
{
return IntervalAutoAnnouncer;
}
public static void setIntervalAutoAnnouncer(int intervalAutoAnnouncer)
{
IntervalAutoAnnouncer = intervalAutoAnnouncer;
}
public static List<AutoAnnouncerMessage> getAutoAnnouncerMessages()
{
return AutoAnnouncerMessages;
}
public static void addAutoAnnouncerMessages(AutoAnnouncerMessage autoAnnouncerMessages)
{
AutoAnnouncerMessages.Add(autoAnnouncerMessages);
}
public static void setMessageOfTheDay(List<string> _messageOfTheDay)
{
MessageOfTheDay = _messageOfTheDay;
}
public static List<string> getMessageOfTheDay()
{
return MessageOfTheDay;
}
}
internal class LoadDatabase
{
public static void LoadAllConfig()
{
LoadDefaultAnnounce();
LoadUsersConfigOnline();
LoadUsersConfigOffline();
LoadPrefabsName();
LoadPrefabsIgnore();
VBloodNotifyIgnoreConfig();
LoadAutoAnnouncerMessagesConfig();
LoadMessageOfTheDayConfig();
}
public static void LoadDefaultAnnounce()
{
Database.setDefaultAnnounce(JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "default_announce.json"))));
}
public static void LoadUsersConfigOnline()
{
Database.setUsersOnline(JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "users_online.json"))));
}
public static void LoadUsersConfigOffline()
{
Database.setUsersOffline(JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "users_offline.json"))));
}
public static void LoadPrefabsName()
{
Database.setPrefabsNames(JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "prefabs_names.json"))));
}
public static void LoadPrefabsIgnore()
{
Database.setPrefabsIgnore(JsonSerializer.Deserialize<Dictionary<string, bool>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "prefabs_names_ignore.json"))));
}
public static void VBloodNotifyIgnoreConfig()
{
Database.setVBloodNotifyIgnore(JsonSerializer.Deserialize<Dictionary<string, bool>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "vbloodannounce_ignore_users.json"))));
}
public static void LoadAutoAnnouncerMessagesConfig()
{
string content = File.ReadAllText(Path.Combine(Config.ConfigPath, "auto_announcer_messages.json"));
foreach (AutoAnnouncerMessage item in new MessageParser().Parse(content))
{
Database.addAutoAnnouncerMessages(item);
}
}
public static void LoadMessageOfTheDayConfig()
{
Database.setMessageOfTheDay(JsonSerializer.Deserialize<List<string>>(File.ReadAllText(Path.Combine(Config.ConfigPath, "message_of_the_day.json"))));
}
}
public enum NotifyFeature
{
motd,
newuser,
offline,
online,
auto,
vblood
}
internal class SaveDatabase
{
public static readonly string ConfigPath = Path.Combine(Paths.ConfigPath, "Notify");
public static void SaveVBloodNotifyIgnoreConfig(Dictionary<string, bool> VBloodAnnounceIgnoreUsers)
{
string contents = JsonSerializer.Serialize(VBloodAnnounceIgnoreUsers, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(Path.Combine(ConfigPath, "vbloodannounce_ignore_users.json"), contents);
}
}
}
namespace BloodyNotify.Command
{
[CommandGroup("bn", null)]
internal class BloodyNotifyCommand
{
[Command("online", "o", null, "To reload the configuration of the user messages online, offline or death of the VBlood boss", null, false)]
public static void Online(ChatCommandContext ctx)
{
ctx.Reply("Users Online ---------");
foreach (UserModel item in GameData.Users.Online.OrderBy((UserModel x) => x.IsAdmin))
{
if (item.IsAdmin)
{
ctx.Reply(FontColorChatSystem.Green("[ADMIN]") + " " + FontColorChatSystem.Yellow(item.CharacterName));
}
else
{
ctx.Reply(FontColorChatSystem.Yellow(item.CharacterName) ?? "");
}
}
}
[Command("reload", "rl", null, "To reload the configuration of the user messages online, offline or death of the VBlood boss", null, true)]
public static void RealoadMod(ChatCommandContext ctx)
{
if (!Database.EnabledFeatures[NotifyFeature.offline])
{
LoadDatabase.LoadUsersConfigOffline();
}
if (!Database.EnabledFeatures[NotifyFeature.online])
{
LoadDatabase.LoadUsersConfigOnline();
}
if (!Database.EnabledFeatures[NotifyFeature.vblood])
{
LoadDatabase.LoadPrefabsName();
LoadDatabase.LoadPrefabsIgnore();
}
if (!Database.EnabledFeatures[NotifyFeature.newuser])
{
LoadDatabase.LoadDefaultAnnounce();
}
if (!Database.EnabledFeatures[NotifyFeature.auto])
{
LoadDatabase.LoadAutoAnnouncerMessagesConfig();
}
if (!Database.EnabledFeatures[NotifyFeature.motd])
{
LoadDatabase.LoadMessageOfTheDayConfig();
}
ctx.Reply("Reloaded configuration of BloodyNotify mod.");
}
[Command("vblood", "vba", "ignore/unignore", "ignore/unignore vblood announce system.", null, false)]
public static void Vbloodannounce(ChatCommandContext ctx, string action = "unignore")
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
User user = ctx.User;
if (!(action == "ignore"))
{
if (action == "unignore")
{
Database.removeVBloodNotifyIgnore(((object)(FixedString64Bytes)(ref user.CharacterName)).ToString());
ctx.Reply(FontColorChatSystem.Green("You will receive notifications about the death of the VBlood. To undo this option use the command " + FontColorChatSystem.Yellow(".notify vbloodannounce ignore")));
}
}
else
{
Database.addVBloodNotifyIgnore(((object)(FixedString64Bytes)(ref user.CharacterName)).ToString());
ctx.Reply(FontColorChatSystem.Green("You will not receive any more notifications about the death of the VBlood. To undo this option use the command " + FontColorChatSystem.Yellow(".notify vbloodannounce unignore")));
}
}
[Command("config", "cfg", "[ auto, motd, newuser, online, offline, vblood ] true/false", "Enabled / Disabled the features of the mod. [ auto, motd, newuser, online, offline, vblood ]", null, true)]
public static void ConfigMod(ChatCommandContext ctx, NotifyFeature feature, bool isEnabled)
{
Database.EnabledFeatures[feature] = isEnabled;
string text = feature switch
{
NotifyFeature.motd => "Message of The Day:",
NotifyFeature.newuser => "Announce New User:",
NotifyFeature.online => "Announce Online:",
NotifyFeature.offline => "Announce Offline:",
NotifyFeature.vblood => "VBlood Announcer:",
NotifyFeature.auto => "Auto Announcer:",
_ => throw new NotImplementedException(),
};
string text2 = FontColorChatSystem.Yellow(isEnabled ? "Enabled" : "Disabled");
ctx.Reply(FontColorChatSystem.Green(text + " " + text2));
}
}
}
namespace BloodyNotify.AutoAnnouncer
{
public class AutoAnnouncerFunction
{
private static int __indexMessage;
public static void OnTimedAutoAnnouncer()
{
//IL_0085: 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)
List<AutoAnnouncerMessage> autoAnnouncerMessages = Database.getAutoAnnouncerMessages();
if (autoAnnouncerMessages.Count <= 0)
{
return;
}
if (autoAnnouncerMessages.Count == 1)
{
foreach (string messageLine in autoAnnouncerMessages[0].MessageLines)
{
ServerChatUtils.SendSystemMessageToAllClients(Plugin.SystemsCore.EntityManager, messageLine);
}
return;
}
foreach (string messageLine2 in autoAnnouncerMessages[__indexMessage].MessageLines)
{
ServerChatUtils.SendSystemMessageToAllClients(Plugin.SystemsCore.EntityManager, messageLine2);
}
__indexMessage++;
if (__indexMessage >= autoAnnouncerMessages.Count)
{
__indexMessage = 0;
}
}
public static void StartAutoAnnouncer()
{
CoroutineHandler.StartRepeatingCoroutine((Action)AutoAnnouncerAction, (float)Database.getIntervalAutoAnnouncer());
static void AutoAnnouncerAction()
{
if (Database.EnabledFeatures[NotifyFeature.auto])
{
OnTimedAutoAnnouncer();
}
}
}
}
}
namespace BloodyNotify.AutoAnnouncer.Parser
{
public class MessageParser
{
public IEnumerable<AutoAnnouncerMessage> Parse(string content)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
if (string.IsNullOrWhiteSpace(content))
{
yield break;
}
string[][] array = JsonSerializer.Deserialize<string[][]>(content);
string[][] array2 = array;
foreach (string[] obj in array2)
{
AutoAnnouncerMessage autoAnnouncerMessage = new AutoAnnouncerMessage();
string[] array3 = obj;
foreach (string item in array3)
{
autoAnnouncerMessage.MessageLines.Add(item);
}
yield return autoAnnouncerMessage;
}
}
}
}
namespace BloodyNotify.AutoAnnouncer.Models
{
public class AutoAnnouncerMessage
{
public List<string> MessageLines { get; set; } = new List<string>();
}
}
