using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Netcode;
using UnityEngine;
using WebSocketSharp.Server;
using com.github.luckofthelefty.LethalWebsocketEvents.Events;
using com.github.luckofthelefty.LethalWebsocketEvents.Helpers;
using com.github.luckofthelefty.LethalWebsocketEvents.Managers;
using com.github.luckofthelefty.LethalWebsocketEvents.Patches;
using com.github.luckofthelefty.LethalWebsocketEvents.Server;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LuckOfTheLefty")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Streams Lethal Company in-game events (deaths, monsters, items, rounds) over WebSocket for Streamerbot integration.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+636990f9269cff6b2f191ee6269052b009b73676")]
[assembly: AssemblyProduct("LethalWebsocketEvents")]
[assembly: AssemblyTitle("com.github.luckofthelefty.LethalWebsocketEvents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents
{
internal static class Logger
{
public static ManualLogSource ManualLogSource { get; private set; }
public static void Initialize(ManualLogSource manualLogSource)
{
ManualLogSource = manualLogSource;
}
public static void LogDebug(object data)
{
Log((LogLevel)32, data);
}
public static void LogInfo(object data)
{
Log((LogLevel)16, data);
}
public static void LogWarning(object data)
{
Log((LogLevel)4, data);
}
public static void LogError(object data)
{
Log((LogLevel)2, data);
}
public static void LogFatal(object data)
{
Log((LogLevel)1, data);
}
public static void Log(LogLevel logLevel, object data)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
ManualLogSource manualLogSource = ManualLogSource;
if (manualLogSource != null)
{
manualLogSource.Log(logLevel, data);
}
}
}
[BepInPlugin("com.github.luckofthelefty.LethalWebsocketEvents", "LethalWebsocketEvents", "1.0.0")]
internal class Plugin : BaseUnityPlugin
{
private readonly Harmony _harmony = new Harmony("com.github.luckofthelefty.LethalWebsocketEvents");
internal static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
Logger.Initialize(Logger.CreateLogSource("com.github.luckofthelefty.LethalWebsocketEvents"));
Logger.LogInfo("LethalWebsocketEvents v1.0.0 loaded!");
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
_harmony.PatchAll(typeof(PlayerDeathPatch));
_harmony.PatchAll(typeof(PlayerDamagePatch));
_harmony.PatchAll(typeof(EmotePatch));
_harmony.PatchAll(typeof(RoundPatch));
_harmony.PatchAll(typeof(QuotaPatch));
_harmony.PatchAll(typeof(EnemyPatch));
_harmony.PatchAll(typeof(ItemPatch));
_harmony.PatchAll(typeof(ApparatusPatch));
_harmony.PatchAll(typeof(LandminePatch));
_harmony.PatchAll(typeof(TurretPatch));
_harmony.PatchAll(typeof(TeleporterPatch));
_harmony.PatchAll(typeof(BrackenPatch));
_harmony.PatchAll(typeof(JesterPatch));
_harmony.PatchAll(typeof(GhostGirlPatch));
_harmony.PatchAll(typeof(CoilheadPatch));
_harmony.PatchAll(typeof(MaskedPatch));
_harmony.PatchAll(typeof(NutcrackerPatch));
_harmony.PatchAll(typeof(ForestGiantPatch));
_harmony.PatchAll(typeof(SnareFleaPatch));
_harmony.PatchAll(typeof(SpiderPatch));
_harmony.PatchAll(typeof(BlobPatch));
_harmony.PatchAll(typeof(ThumperPatch));
_harmony.PatchAll(typeof(EyelessDogPatch));
_harmony.PatchAll(typeof(BaboonHawkPatch));
_harmony.PatchAll(typeof(ConnectionPatch));
_harmony.PatchAll(typeof(DisconnectPatch));
_harmony.PatchAll(typeof(VoteToLeavePatch));
Task.Run((Action)EventServer.Initialize);
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.github.luckofthelefty.LethalWebsocketEvents";
public const string PLUGIN_NAME = "LethalWebsocketEvents";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents.Server
{
public class EventBehavior : WebSocketBehavior
{
protected override void OnOpen()
{
GameEvent gameEvent = GameEvent.Create("connected", new Dictionary<string, object>
{
{ "modVersion", "1.0.0" },
{ "modName", "LethalWebsocketEvents" }
});
((WebSocketBehavior)this).Send(JsonConvert.SerializeObject((object)gameEvent));
}
}
internal static class EventServer
{
private static WebSocketServer _webSocketServer;
private static readonly object _broadcastLock = new object();
public static int WebSocketPort => ConfigManager.Server_WebSocketPort.Value;
public static bool IsRunning { get; private set; }
public static void Initialize()
{
Application.quitting += delegate
{
Stop();
};
if (ConfigManager.Server_AutoStart.Value)
{
Start();
}
}
public static void Start()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
if (IsRunning)
{
Logger.LogWarning("Event server is already running!");
return;
}
try
{
IsRunning = true;
_webSocketServer = new WebSocketServer($"ws://{IPAddress.Any}:{WebSocketPort}");
_webSocketServer.AddWebSocketService<EventBehavior>("/events");
_webSocketServer.Start();
if (!_webSocketServer.IsListening)
{
Logger.LogError("Failed to start WebSocket server. The port might already be in use.");
Stop();
}
else
{
Logger.LogInfo($"WebSocket event server started on ws://localhost:{WebSocketPort}/events");
}
}
catch (SocketException ex)
{
Logger.LogError("Failed to start WebSocket server. " + ex.Message);
Stop();
}
catch (Exception arg)
{
Logger.LogError($"Failed to start WebSocket server. {arg}");
Stop();
}
}
public static void Stop()
{
if (IsRunning)
{
IsRunning = false;
WebSocketServer webSocketServer = _webSocketServer;
if (webSocketServer != null)
{
webSocketServer.Stop();
}
_webSocketServer = null;
Logger.LogInfo("Event server stopped.");
}
}
public static void SendEvent(GameEvent gameEvent)
{
if (_webSocketServer == null || !_webSocketServer.IsListening)
{
return;
}
lock (_broadcastLock)
{
try
{
string text = JsonConvert.SerializeObject((object)gameEvent);
if (ConfigManager.ExtendedLogging.Value)
{
Logger.LogInfo("Broadcasting event: " + text);
}
foreach (string path in _webSocketServer.WebSocketServices.Paths)
{
WebSocketServiceHost val = _webSocketServer.WebSocketServices[path];
val.Sessions.Broadcast(text);
}
}
catch (Exception arg)
{
Logger.LogError($"Failed to broadcast event. {arg}");
}
}
}
public static void SendEvent(string eventName, Dictionary<string, object> data = null)
{
SendEvent(GameEvent.Create(eventName, data));
}
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents.Patches
{
[HarmonyPatch(typeof(EnemyAI))]
internal static class EnemyPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartPatch(EnemyAI __instance)
{
if (!((Object)(object)__instance.enemyType == (Object)null))
{
string value = __instance.enemyType.enemyName ?? ((object)__instance).GetType().Name;
bool isOutside = __instance.isOutside;
EventServer.SendEvent("enemy_spawned", new Dictionary<string, object>
{
{ "enemyType", value },
{
"location",
isOutside ? "outdoor" : "indoor"
}
});
}
}
[HarmonyPatch("KillEnemyClientRpc")]
[HarmonyPostfix]
private static void KillEnemyClientRpcPatch(EnemyAI __instance)
{
if (NetworkUtils.ShouldProcess($"enemy_killed_{((Object)__instance).GetInstanceID()}") && !((Object)(object)__instance.enemyType == (Object)null))
{
string value = __instance.enemyType.enemyName ?? ((object)__instance).GetType().Name;
EventServer.SendEvent("enemy_killed", new Dictionary<string, object> { { "enemyType", value } });
}
}
[HarmonyPatch("SwitchToBehaviourClientRpc")]
[HarmonyPostfix]
private static void SwitchToBehaviourClientRpcPatch(EnemyAI __instance, int stateIndex)
{
if (NetworkUtils.ShouldProcess($"enemy_state_{((Object)__instance).GetInstanceID()}_{stateIndex}") && !((Object)(object)__instance.enemyType == (Object)null))
{
string value = __instance.enemyType.enemyName ?? ((object)__instance).GetType().Name;
EventServer.SendEvent("enemy_state_changed", new Dictionary<string, object>
{
{ "enemyType", value },
{ "state", stateIndex }
});
}
}
[HarmonyPatch("HitEnemyClientRpc")]
[HarmonyPostfix]
private static void HitEnemyClientRpcPatch(EnemyAI __instance, int force, int playerWhoHit, bool playHitSFX, int hitID)
{
if (NetworkUtils.ShouldProcess($"enemy_hit_{((Object)__instance).GetInstanceID()}_{hitID}") && !((Object)(object)__instance.enemyType == (Object)null))
{
string value = __instance.enemyType.enemyName ?? ((object)__instance).GetType().Name;
string playerName = PlayerUtils.GetPlayerName(playerWhoHit);
EventServer.SendEvent("enemy_hit", new Dictionary<string, object>
{
{ "enemyType", value },
{ "player", playerName },
{ "force", force }
});
}
}
}
[HarmonyPatch(typeof(Landmine))]
internal static class LandminePatch
{
[HarmonyPatch("ExplodeMineClientRpc")]
[HarmonyPostfix]
private static void ExplodeMineClientRpcPatch(Landmine __instance)
{
if (NetworkUtils.ShouldProcess($"landmine_{((Object)__instance).GetInstanceID()}"))
{
EventServer.SendEvent("landmine_exploded", new Dictionary<string, object>());
}
}
}
[HarmonyPatch(typeof(Turret))]
internal static class TurretPatch
{
[HarmonyPatch("SetToModeClientRpc")]
[HarmonyPostfix]
private static void SetToModeClientRpcPatch(Turret __instance, int mode)
{
if (NetworkUtils.ShouldProcess($"turret_{((Object)__instance).GetInstanceID()}_{mode}"))
{
string[] array = new string[4] { "Detection", "Charging", "Firing", "Berserk" };
string value = ((mode >= 0 && mode < array.Length) ? array[mode] : "Unknown");
EventServer.SendEvent("turret_mode_changed", new Dictionary<string, object>
{
{ "mode", value },
{ "modeIndex", mode }
});
}
}
}
[HarmonyPatch(typeof(ShipTeleporter))]
internal static class TeleporterPatch
{
[HarmonyPatch("PressTeleportButtonClientRpc")]
[HarmonyPostfix]
private static void PressTeleportButtonClientRpcPatch(ShipTeleporter __instance)
{
if (NetworkUtils.ShouldProcess($"teleporter_{((Object)__instance).GetInstanceID()}"))
{
EventServer.SendEvent("teleporter_used", new Dictionary<string, object> { { "isInverse", __instance.isInverseTeleporter } });
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class ItemPatch
{
[HarmonyPatch("GrabObjectClientRpc")]
[HarmonyPostfix]
private static void GrabObjectClientRpcPatch(PlayerControllerB __instance, NetworkObjectReference grabbedObject)
{
if (NetworkUtils.ShouldProcess($"item_grab_{((Object)__instance).GetInstanceID()}") && PlayerUtils.ShouldTrackPlayer(__instance))
{
string playerName = PlayerUtils.GetPlayerName(__instance);
string value = "Unknown";
int num = 0;
NetworkObject val = default(NetworkObject);
GrabbableObject val2 = default(GrabbableObject);
if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null) && ((Component)val).TryGetComponent<GrabbableObject>(ref val2))
{
value = val2.itemProperties?.itemName ?? "Unknown";
num = val2.scrapValue;
}
EventServer.SendEvent("item_grabbed", new Dictionary<string, object>
{
{ "player", playerName },
{ "item", value },
{ "scrapValue", num }
});
}
}
[HarmonyPatch("ThrowObjectClientRpc")]
[HarmonyPostfix]
private static void ThrowObjectClientRpcPatch(PlayerControllerB __instance, bool droppedInElevator, bool droppedInShipRoom)
{
if (NetworkUtils.ShouldProcess($"item_drop_{((Object)__instance).GetInstanceID()}") && PlayerUtils.ShouldTrackPlayer(__instance))
{
string playerName = PlayerUtils.GetPlayerName(__instance);
EventServer.SendEvent("item_dropped", new Dictionary<string, object>
{
{ "player", playerName },
{
"inShip",
droppedInElevator || droppedInShipRoom
}
});
}
}
}
[HarmonyPatch(typeof(LungProp))]
internal static class ApparatusPatch
{
[HarmonyPatch("DisconnectFromMachinery")]
[HarmonyPostfix]
private static void DisconnectFromMachineryPatch(LungProp __instance)
{
string value = "Unknown";
if (((GrabbableObject)__instance).isHeld && (Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)null)
{
if (!PlayerUtils.ShouldTrackPlayer(((GrabbableObject)__instance).playerHeldBy))
{
return;
}
value = PlayerUtils.GetPlayerName(((GrabbableObject)__instance).playerHeldBy);
}
EventServer.SendEvent("apparatus_pulled", new Dictionary<string, object> { { "player", value } });
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class ConnectionPatch
{
[HarmonyPatch("SendNewPlayerValuesClientRpc")]
[HarmonyPostfix]
private static void SendNewPlayerValuesClientRpcPatch(PlayerControllerB __instance)
{
if (NetworkUtils.ShouldProcess($"player_joined_{((Object)__instance).GetInstanceID()}"))
{
string playerName = PlayerUtils.GetPlayerName(__instance);
int connectedPlayerCount = PlayerUtils.GetConnectedPlayerCount();
EventServer.SendEvent("player_joined", new Dictionary<string, object>
{
{ "player", playerName },
{ "playerCount", connectedPlayerCount }
});
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal static class DisconnectPatch
{
[HarmonyPatch("OnPlayerDC")]
[HarmonyPostfix]
private static void OnPlayerDCPatch(int playerObjectNumber)
{
string value = "Unknown";
if (StartOfRound.Instance?.allPlayerScripts != null && playerObjectNumber >= 0 && playerObjectNumber < StartOfRound.Instance.allPlayerScripts.Length)
{
value = PlayerUtils.GetPlayerName(StartOfRound.Instance.allPlayerScripts[playerObjectNumber]);
}
int connectedPlayerCount = PlayerUtils.GetConnectedPlayerCount();
EventServer.SendEvent("player_left", new Dictionary<string, object>
{
{ "player", value },
{ "playerCount", connectedPlayerCount }
});
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class EmotePatch
{
[HarmonyPatch("PerformEmote")]
[HarmonyPostfix]
private static void PerformEmotePatch(PlayerControllerB __instance, int emoteID)
{
if (PlayerUtils.ShouldTrackPlayer(__instance))
{
string playerName = PlayerUtils.GetPlayerName(__instance);
EventServer.SendEvent("player_emote", new Dictionary<string, object>
{
{ "player", playerName },
{ "emoteId", emoteID }
});
}
}
}
[HarmonyPatch(typeof(TimeOfDay))]
internal static class VoteToLeavePatch
{
[HarmonyPatch("VoteShipToLeaveEarly")]
[HarmonyPostfix]
private static void VoteShipToLeaveEarlyPatch()
{
EventServer.SendEvent("vote_to_leave", new Dictionary<string, object>());
}
}
[HarmonyPatch(typeof(FlowermanAI))]
internal static class BrackenPatch
{
[HarmonyPatch("KillPlayerAnimationClientRpc")]
[HarmonyPostfix]
private static void KillPlayerAnimationClientRpcPatch(FlowermanAI __instance, int playerObjectId)
{
if (NetworkUtils.ShouldProcess($"bracken_grab_{playerObjectId}"))
{
string playerName = PlayerUtils.GetPlayerName(playerObjectId);
EventServer.SendEvent("bracken_grab", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(JesterAI))]
internal static class JesterPatch
{
[HarmonyPatch("KillPlayerClientRpc")]
[HarmonyPostfix]
private static void KillPlayerClientRpcPatch(JesterAI __instance, int playerId)
{
if (NetworkUtils.ShouldProcess($"jester_kill_{playerId}"))
{
string playerName = PlayerUtils.GetPlayerName(playerId);
EventServer.SendEvent("jester_kill", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(DressGirlAI))]
internal static class GhostGirlPatch
{
[HarmonyPatch("ChooseNewHauntingPlayerClientRpc")]
[HarmonyPostfix]
private static void ChooseNewHauntingPlayerClientRpcPatch(DressGirlAI __instance)
{
if (NetworkUtils.ShouldProcess($"ghost_haunt_{((Object)__instance).GetInstanceID()}"))
{
string value = "Unknown";
if ((Object)(object)__instance.hauntingPlayer != (Object)null)
{
value = PlayerUtils.GetPlayerName(__instance.hauntingPlayer);
}
EventServer.SendEvent("ghost_girl_haunt", new Dictionary<string, object> { { "player", value } });
}
}
}
[HarmonyPatch(typeof(SpringManAI))]
internal static class CoilheadPatch
{
[HarmonyPatch("SetAnimationGoClientRpc")]
[HarmonyPostfix]
private static void SetAnimationGoClientRpcPatch(SpringManAI __instance)
{
if (NetworkUtils.ShouldProcess($"coilhead_go_{((Object)__instance).GetInstanceID()}"))
{
EventServer.SendEvent("coilhead_moving", new Dictionary<string, object>());
}
}
[HarmonyPatch("SetAnimationStopClientRpc")]
[HarmonyPostfix]
private static void SetAnimationStopClientRpcPatch(SpringManAI __instance)
{
if (NetworkUtils.ShouldProcess($"coilhead_stop_{((Object)__instance).GetInstanceID()}"))
{
EventServer.SendEvent("coilhead_stopped", new Dictionary<string, object>());
}
}
}
[HarmonyPatch(typeof(MaskedPlayerEnemy))]
internal static class MaskedPatch
{
[HarmonyPatch("CreateMimicClientRpc")]
[HarmonyPostfix]
private static void CreateMimicClientRpcPatch(MaskedPlayerEnemy __instance)
{
if (NetworkUtils.ShouldProcess($"masked_mimic_{((Object)__instance).GetInstanceID()}"))
{
string value = (((Object)(object)__instance.mimickingPlayer != (Object)null) ? PlayerUtils.GetPlayerName(__instance.mimickingPlayer) : "Unknown");
EventServer.SendEvent("masked_mimic", new Dictionary<string, object> { { "mimicking", value } });
}
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI))]
internal static class NutcrackerPatch
{
[HarmonyPatch("FireGunClientRpc")]
[HarmonyPostfix]
private static void FireGunClientRpcPatch(NutcrackerEnemyAI __instance)
{
if (NetworkUtils.ShouldProcess($"nutcracker_shot_{((Object)__instance).GetInstanceID()}"))
{
EventServer.SendEvent("nutcracker_shot", new Dictionary<string, object>());
}
}
}
[HarmonyPatch(typeof(ForestGiantAI))]
internal static class ForestGiantPatch
{
[HarmonyPatch("GrabPlayerClientRpc")]
[HarmonyPostfix]
private static void GrabPlayerClientRpcPatch(ForestGiantAI __instance, int playerId)
{
if (NetworkUtils.ShouldProcess($"giant_grab_{playerId}"))
{
string playerName = PlayerUtils.GetPlayerName(playerId);
EventServer.SendEvent("giant_grab", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(CentipedeAI))]
internal static class SnareFleaPatch
{
[HarmonyPatch("ClingToPlayerClientRpc")]
[HarmonyPostfix]
private static void ClingToPlayerClientRpcPatch(CentipedeAI __instance)
{
if (NetworkUtils.ShouldProcess($"snare_flea_{((Object)__instance).GetInstanceID()}"))
{
string value = "Unknown";
if ((Object)(object)__instance.clingingToPlayer != (Object)null)
{
value = PlayerUtils.GetPlayerName(__instance.clingingToPlayer);
}
EventServer.SendEvent("snare_flea_cling", new Dictionary<string, object> { { "player", value } });
}
}
}
[HarmonyPatch(typeof(SandSpiderAI))]
internal static class SpiderPatch
{
[HarmonyPatch("PlayerTripWebClientRpc")]
[HarmonyPostfix]
private static void PlayerTripWebClientRpcPatch(SandSpiderAI __instance, int playerNum)
{
if (NetworkUtils.ShouldProcess($"spider_web_{((Object)__instance).GetInstanceID()}_{playerNum}"))
{
string playerName = PlayerUtils.GetPlayerName(playerNum);
EventServer.SendEvent("spider_web_trip", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(BlobAI))]
internal static class BlobPatch
{
[HarmonyPatch("SlimeKillPlayerEffectClientRpc")]
[HarmonyPostfix]
private static void SlimeKillPlayerEffectClientRpcPatch(BlobAI __instance, int playerKilled)
{
if (NetworkUtils.ShouldProcess($"blob_kill_{playerKilled}"))
{
string playerName = PlayerUtils.GetPlayerName(playerKilled);
EventServer.SendEvent("blob_kill", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(CrawlerAI))]
internal static class ThumperPatch
{
[HarmonyPatch("HitPlayerClientRpc")]
[HarmonyPostfix]
private static void HitPlayerClientRpcPatch(CrawlerAI __instance, int playerId)
{
if (NetworkUtils.ShouldProcess($"thumper_hit_{playerId}"))
{
string playerName = PlayerUtils.GetPlayerName(playerId);
EventServer.SendEvent("thumper_hit", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(MouthDogAI))]
internal static class EyelessDogPatch
{
[HarmonyPatch("KillPlayerClientRpc")]
[HarmonyPostfix]
private static void KillPlayerClientRpcPatch(MouthDogAI __instance, int playerId)
{
if (NetworkUtils.ShouldProcess($"dog_kill_{playerId}"))
{
string playerName = PlayerUtils.GetPlayerName(playerId);
EventServer.SendEvent("eyeless_dog_kill", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(BaboonBirdAI))]
internal static class BaboonHawkPatch
{
[HarmonyPatch("StabPlayerDeathAnimClientRpc")]
[HarmonyPostfix]
private static void StabPlayerDeathAnimClientRpcPatch(BaboonBirdAI __instance, int playerObject)
{
if (NetworkUtils.ShouldProcess($"baboon_stab_{playerObject}"))
{
string playerName = PlayerUtils.GetPlayerName(playerObject);
EventServer.SendEvent("baboon_hawk_stab", new Dictionary<string, object> { { "player", playerName } });
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class PlayerDamagePatch
{
[HarmonyPatch("DamagePlayerClientRpc")]
[HarmonyPostfix]
private static void DamagePlayerClientRpcPatch(PlayerControllerB __instance, int damageNumber)
{
if (!NetworkUtils.ShouldProcess($"damage_{((Object)__instance).GetInstanceID()}_{damageNumber}") || !PlayerUtils.ShouldTrackPlayer(__instance))
{
return;
}
string playerName = PlayerUtils.GetPlayerName(__instance);
if (damageNumber < 0)
{
EventServer.SendEvent("player_healed", new Dictionary<string, object>
{
{ "player", playerName },
{
"amount",
-damageNumber
},
{ "health", __instance.health }
});
return;
}
string text = EnemyUtils.FindAttackingEnemy(__instance);
Dictionary<string, object> dictionary = new Dictionary<string, object>
{
{ "player", playerName },
{ "damage", damageNumber },
{ "health", __instance.health },
{
"critical",
__instance.health <= 0
}
};
if (text != null)
{
dictionary["enemy"] = text;
}
EventServer.SendEvent("player_damage", dictionary);
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class PlayerDeathPatch
{
[HarmonyPatch("KillPlayerClientRpc")]
[HarmonyPostfix]
private static void KillPlayerClientRpcPatch(PlayerControllerB __instance, int playerId, int causeOfDeath)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkUtils.ShouldProcess($"death_{playerId}"))
{
return;
}
PlayerControllerB playerScript = ((StartOfRound.Instance?.allPlayerScripts != null && playerId >= 0 && playerId < StartOfRound.Instance.allPlayerScripts.Length) ? StartOfRound.Instance.allPlayerScripts[playerId] : __instance);
if (PlayerUtils.ShouldTrackPlayer(playerScript))
{
string playerName = PlayerUtils.GetPlayerName(playerScript);
CauseOfDeath val = (CauseOfDeath)causeOfDeath;
string value = ((object)(CauseOfDeath)(ref val)).ToString();
string text = EnemyUtils.FindAttackingEnemy(playerScript);
Dictionary<string, object> dictionary = new Dictionary<string, object>
{
{ "player", playerName },
{ "causeOfDeath", value },
{ "playerId", playerId }
};
if (text != null)
{
dictionary["enemy"] = text;
}
EventServer.SendEvent("player_death", dictionary);
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal static class RoundPatch
{
private static DateTime _lastDayChangedTime = DateTime.MinValue;
private static string _lastDayChangedKey = "";
private static readonly TimeSpan EventDebounce = TimeSpan.FromSeconds(2.0);
private static DateTime _lastShipLandedTime = DateTime.MinValue;
[HarmonyPatch("StartGame")]
[HarmonyPostfix]
private static void StartGamePatch()
{
string value = StartOfRound.Instance?.currentLevel?.PlanetName ?? "Unknown";
StartOfRound instance = StartOfRound.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
SelectableLevel currentLevel = instance.currentLevel;
obj = ((currentLevel != null) ? ((object)(LevelWeatherType)(ref currentLevel.currentWeather)).ToString() : null);
}
if (obj == null)
{
obj = "None";
}
string value2 = (string)obj;
EventServer.SendEvent("round_start", new Dictionary<string, object>
{
{ "moon", value },
{ "weather", value2 }
});
}
[HarmonyPatch("EndOfGame")]
[HarmonyPrefix]
private static void EndOfGamePatch()
{
EventServer.SendEvent("round_end", new Dictionary<string, object>());
}
[HarmonyPatch("ShipLeave")]
[HarmonyPostfix]
private static void ShipLeavePatch()
{
EventServer.SendEvent("ship_leaving", new Dictionary<string, object>());
}
[HarmonyPatch("ReviveDeadPlayers")]
[HarmonyPostfix]
private static void ReviveDeadPlayersPatch()
{
EventServer.SendEvent("players_revived", new Dictionary<string, object>());
}
[HarmonyPatch("SetMapScreenInfoToCurrentLevel")]
[HarmonyPostfix]
private static void SetMapScreenInfoToCurrentLevelPatch()
{
string text = StartOfRound.Instance?.currentLevel?.PlanetName ?? "Unknown";
StartOfRound instance = StartOfRound.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
SelectableLevel currentLevel = instance.currentLevel;
obj = ((currentLevel != null) ? ((object)(LevelWeatherType)(ref currentLevel.currentWeather)).ToString() : null);
}
if (obj == null)
{
obj = "None";
}
string text2 = (string)obj;
string text3 = text + "|" + text2;
DateTime utcNow = DateTime.UtcNow;
if (!(utcNow - _lastDayChangedTime < EventDebounce) || !(_lastDayChangedKey == text3))
{
_lastDayChangedTime = utcNow;
_lastDayChangedKey = text3;
EventServer.SendEvent("day_changed", new Dictionary<string, object>
{
{ "moon", text },
{ "weather", text2 }
});
}
}
[HarmonyPatch("ChangeLevelClientRpc")]
[HarmonyPostfix]
private static void ChangeLevelClientRpcPatch(StartOfRound __instance)
{
if (NetworkUtils.ShouldProcess("moon_changed"))
{
string value = StartOfRound.Instance?.currentLevel?.PlanetName ?? "Unknown";
StartOfRound instance = StartOfRound.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
SelectableLevel currentLevel = instance.currentLevel;
obj = ((currentLevel != null) ? ((object)(LevelWeatherType)(ref currentLevel.currentWeather)).ToString() : null);
}
if (obj == null)
{
obj = "None";
}
string value2 = (string)obj;
EventServer.SendEvent("moon_changed", new Dictionary<string, object>
{
{ "moon", value },
{ "weather", value2 }
});
}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void OpeningDoorsSequencePatch()
{
DateTime utcNow = DateTime.UtcNow;
if (!(utcNow - _lastShipLandedTime < EventDebounce))
{
_lastShipLandedTime = utcNow;
string value = StartOfRound.Instance?.currentLevel?.PlanetName ?? "Unknown";
EventServer.SendEvent("ship_landed", new Dictionary<string, object> { { "moon", value } });
}
}
}
[HarmonyPatch(typeof(TimeOfDay))]
internal static class QuotaPatch
{
[HarmonyPatch("SyncNewProfitQuotaClientRpc")]
[HarmonyPostfix]
private static void SyncNewProfitQuotaClientRpcPatch(TimeOfDay __instance)
{
if (NetworkUtils.ShouldProcess("quota_fulfilled"))
{
int num = TimeOfDay.Instance?.profitQuota ?? 0;
int num2 = (TimeOfDay.Instance?.timesFulfilledQuota ?? 0) + 1;
EventServer.SendEvent("quota_fulfilled", new Dictionary<string, object>
{
{ "newQuota", num },
{ "quotaIndex", num2 }
});
}
}
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents.Managers
{
internal static class ConfigManager
{
public static ConfigFile ConfigFile { get; private set; }
public static ConfigEntry<bool> ExtendedLogging { get; private set; }
public static ConfigEntry<bool> Server_AutoStart { get; private set; }
public static ConfigEntry<int> Server_WebSocketPort { get; private set; }
public static ConfigEntry<bool> Filter_LocalPlayerOnly { get; private set; }
public static ConfigEntry<string> Filter_PlayerName { get; private set; }
public static void Initialize(ConfigFile configFile)
{
ConfigFile = configFile;
ExtendedLogging = configFile.Bind<bool>("General", "ExtendedLogging", false, "Enable extended logging for debugging.");
Server_AutoStart = configFile.Bind<bool>("Server", "AutoStart", true, "If enabled, the WebSocket server will automatically start when the game launches.");
Server_WebSocketPort = configFile.Bind<int>("Server", "WebSocketPort", 8765, "The WebSocket port for the event server.");
Filter_LocalPlayerOnly = configFile.Bind<bool>("Filter", "LocalPlayerOnly", false, "If enabled, player-specific events (death, damage, items) only fire for the local player. Global events (enemy spawns, round start, etc.) always fire regardless of this setting.");
Filter_PlayerName = configFile.Bind<string>("Filter", "PlayerName", "", "If set, player-specific events only fire for this player name. Leave empty to use LocalPlayerOnly logic instead. Useful if you want to track a specific player who isn't running the mod.");
}
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents.Helpers
{
internal static class EnemyUtils
{
public static string FindAttackingEnemy(PlayerControllerB playerScript)
{
if ((Object)(object)playerScript == (Object)null)
{
return null;
}
if ((Object)(object)playerScript.inAnimationWithEnemy != (Object)null)
{
return GetEnemyName(playerScript.inAnimationWithEnemy);
}
EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
if (array == null)
{
return null;
}
EnemyAI[] array2 = array;
foreach (EnemyAI val in array2)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)val.enemyType == (Object)null))
{
if ((Object)(object)val.inSpecialAnimationWithPlayer == (Object)(object)playerScript)
{
return GetEnemyName(val);
}
if ((Object)(object)val.targetPlayer == (Object)(object)playerScript && val.movingTowardsTargetPlayer)
{
return GetEnemyName(val);
}
}
}
return null;
}
private static string GetEnemyName(EnemyAI enemy)
{
if ((Object)(object)enemy?.enemyType == (Object)null)
{
return null;
}
return enemy.enemyType.enemyName ?? ((object)enemy).GetType().Name;
}
}
internal static class NetworkUtils
{
private static readonly Dictionary<string, int> _lastProcessedFrame = new Dictionary<string, int>();
public static bool IsConnected
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsConnectedClient;
}
}
public static bool IsServer
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsServer;
}
}
public static ulong GetLocalClientId()
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return 0uL;
}
return singleton.LocalClientId;
}
public static bool IsLocalClientId(ulong clientId)
{
return clientId == GetLocalClientId();
}
public static bool ShouldProcess(string eventKey)
{
int frameCount = Time.frameCount;
if (_lastProcessedFrame.TryGetValue(eventKey, out var value) && value == frameCount)
{
return false;
}
_lastProcessedFrame[eventKey] = frameCount;
return true;
}
}
internal static class PlayerUtils
{
public static PlayerControllerB GetLocalPlayerScript()
{
if ((Object)(object)GameNetworkManager.Instance == (Object)null)
{
return null;
}
return GameNetworkManager.Instance.localPlayerController;
}
public static bool IsLocalPlayer(PlayerControllerB playerScript)
{
return (Object)(object)playerScript == (Object)(object)GetLocalPlayerScript();
}
public static bool IsLocalPlayerSpawned()
{
return (Object)(object)GetLocalPlayerScript() != (Object)null;
}
public static PlayerControllerB GetPlayerScriptByClientId(ulong clientId)
{
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
return null;
}
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val in allPlayerScripts)
{
if (val.actualClientId == clientId)
{
return val;
}
}
return null;
}
public static int GetConnectedPlayerCount()
{
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
return 1;
}
return StartOfRound.Instance.connectedPlayersAmount + 1;
}
public static string GetPlayerName(PlayerControllerB playerScript)
{
if ((Object)(object)playerScript == (Object)null)
{
return "Unknown";
}
return playerScript.playerUsername ?? "Unknown";
}
public static string GetPlayerName(int playerObjectIndex)
{
if (StartOfRound.Instance?.allPlayerScripts == null || playerObjectIndex < 0 || playerObjectIndex >= StartOfRound.Instance.allPlayerScripts.Length)
{
return "Unknown";
}
return GetPlayerName(StartOfRound.Instance.allPlayerScripts[playerObjectIndex]);
}
public static bool ShouldTrackPlayer(PlayerControllerB playerScript)
{
string text = ConfigManager.Filter_PlayerName?.Value;
if (!string.IsNullOrEmpty(text))
{
string playerName = GetPlayerName(playerScript);
return string.Equals(playerName, text, StringComparison.OrdinalIgnoreCase);
}
ConfigEntry<bool> filter_LocalPlayerOnly = ConfigManager.Filter_LocalPlayerOnly;
if (filter_LocalPlayerOnly != null && filter_LocalPlayerOnly.Value)
{
return IsLocalPlayer(playerScript);
}
return true;
}
public static bool ShouldTrackPlayer(string playerName)
{
string text = ConfigManager.Filter_PlayerName?.Value;
if (!string.IsNullOrEmpty(text))
{
return string.Equals(playerName, text, StringComparison.OrdinalIgnoreCase);
}
ConfigEntry<bool> filter_LocalPlayerOnly = ConfigManager.Filter_LocalPlayerOnly;
if (filter_LocalPlayerOnly != null && filter_LocalPlayerOnly.Value)
{
PlayerControllerB localPlayerScript = GetLocalPlayerScript();
if ((Object)(object)localPlayerScript != (Object)null)
{
return string.Equals(GetPlayerName(localPlayerScript), playerName, StringComparison.OrdinalIgnoreCase);
}
return false;
}
return true;
}
public static bool ShouldTrackPlayer(int playerId)
{
if (StartOfRound.Instance?.allPlayerScripts == null || playerId < 0 || playerId >= StartOfRound.Instance.allPlayerScripts.Length)
{
return true;
}
return ShouldTrackPlayer(StartOfRound.Instance.allPlayerScripts[playerId]);
}
}
}
namespace com.github.luckofthelefty.LethalWebsocketEvents.Events
{
internal class GameEvent
{
[JsonProperty("event")]
public string Event { get; set; }
[JsonProperty("timestamp")]
public string Timestamp { get; set; }
[JsonProperty("data")]
public Dictionary<string, object> Data { get; set; }
public GameEvent(string eventName, Dictionary<string, object> data = null)
{
Event = eventName;
Timestamp = DateTime.UtcNow.ToString("o");
Data = data ?? new Dictionary<string, object>();
}
public static GameEvent Create(string eventName, Dictionary<string, object> data = null)
{
return new GameEvent(eventName, data);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
