using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Discord;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalLetdownBot.Client;
using LethalLetdownBot.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Steamworks;
using Steamworks.Data;
using Unity.Netcode;
using UnityEngine;
[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("packsolite.lethalletdownbot")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+bb9a837a2900004f9e5c17e2214be18e77af65d7")]
[assembly: AssemblyProduct("LethalLetdownBot")]
[assembly: AssemblyTitle("packsolite.lethalletdownbot")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LethalLetdownBot
{
[BepInPlugin("packsolite.lethalletdownbot", "LethalLetdownBot", "1.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class LethalLetdownBot : BaseUnityPlugin
{
public static LethalLetdownBot Instance { get; private set; } = null;
internal static ManualLogSource Logger { get; private set; } = null;
internal static Harmony Harmony { get; set; } = null;
internal static string Token { get; set; } = null;
internal static string URL { get; set; } = null;
internal static bool Enabled { get; set; } = true;
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
LoadConfig();
Token = UserUtil.GetOrCreateUserId();
Patch();
Logger.LogInfo((object)"packsolite.lethalletdownbot v1.1.0 has loaded!");
}
internal static void Patch()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
if (Harmony == null)
{
Harmony = new Harmony("packsolite.lethalletdownbot");
}
Harmony.PatchAll();
}
internal static void Unpatch()
{
Harmony harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void LoadConfig()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
ConfigEntry<bool> enableEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable bot", true, "Controls wether the bot announces the lobby on discord. Can be used to quickly toggle the bot while the game is running.");
BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(enableEntry, false);
ConfigEntry<string> endpointEntry = ((BaseUnityPlugin)this).Config.Bind<string>("Configuration", "Endpoint", "http://localhost:8080/", "Endpoint to use for the LethalLetdown-Bot");
TextInputFieldConfigItem val2 = new TextInputFieldConfigItem(endpointEntry, false);
endpointEntry.SettingChanged += ApplyConfig;
enableEntry.SettingChanged += ApplyConfig;
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
ApplyConfig(null, null);
void ApplyConfig(object? obj, EventArgs? args)
{
URL = endpointEntry.Value.TrimEnd('/') + "/";
Enabled = enableEntry.Value;
if (Enabled)
{
LobbyManager.Instance.CreateLobby();
}
else
{
LobbyManager.Instance.DeleteLobby();
}
}
}
}
public class LobbyManager
{
private static readonly Lazy<LobbyManager> _instance = new Lazy<LobbyManager>(() => new LobbyManager());
public static LobbyManager Instance => _instance.Value;
private LobbyManager()
{
}
public void CreateLobby()
{
//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_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
StartOfRound instance = StartOfRound.Instance;
if (instance == null || !((NetworkBehaviour)instance).IsHost)
{
return;
}
string lobbyName = GameNetworkManager.Instance.lobbyHostSettings.lobbyName;
GameNetworkManager instance2 = GameNetworkManager.Instance;
object obj;
if (instance2 == null)
{
obj = null;
}
else
{
Lobby? currentLobby = instance2.currentLobby;
if (!currentLobby.HasValue)
{
obj = null;
}
else
{
Lobby valueOrDefault = currentLobby.GetValueOrDefault();
SteamId id = ((Lobby)(ref valueOrDefault)).Id;
obj = ((object)(SteamId)(ref id)).ToString();
}
}
if (obj == null)
{
obj = string.Empty;
}
string steamLobbyId = (string)obj;
bool isPublic = GameNetworkManager.Instance?.lobbyHostSettings.isLobbyPublic ?? false;
LobbyStatus currentLobbyStatus = GetCurrentLobbyStatus();
LobbyOwner currentLobbyOwner = GetCurrentLobbyOwner();
RestClient.Instance.CreateLobby(currentLobbyOwner, currentLobbyStatus, lobbyName, steamLobbyId, isPublic).ContinueWith(delegate(Task t)
{
if (t.IsFaulted)
{
LogHelper.Error(t.Exception?.GetBaseException(), "Failed creating lobby");
}
});
}
public void UpdateLobby()
{
LobbyStatus status = GetCurrentLobbyStatus();
RestClient.Instance.UpdateLobbyStatus(status).ContinueWith(delegate(Task t)
{
LogHelper.LogFaulted(t, $"Failed updating lobby status {status}");
});
}
public void DeleteLobby()
{
RestClient.Instance.DestroyLobby().ContinueWith(delegate(Task t)
{
LogHelper.LogFaulted(t, "Failed deleting lobby");
});
}
private static LobbyStatus GetCurrentLobbyStatus()
{
//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)
StartOfRound instance = StartOfRound.Instance;
SelectableLevel currentLevel = instance.currentLevel;
CurrentMoon currentMoon = (((Object)(object)currentLevel != (Object)null) ? CurrentMoon.FromSelectableLevel(currentLevel) : null);
int connectedPlayers = GameNetworkManager.Instance.connectedPlayers;
GameNetworkManager instance2 = GameNetworkManager.Instance;
int? obj;
if (instance2 == null)
{
obj = null;
}
else
{
Lobby? currentLobby = instance2.currentLobby;
if (!currentLobby.HasValue)
{
obj = null;
}
else
{
Lobby valueOrDefault = currentLobby.GetValueOrDefault();
obj = ((Lobby)(ref valueOrDefault)).MaxMembers;
}
}
int? num = obj;
int valueOrDefault2 = num.GetValueOrDefault(4);
ShipStatus shipStatus = (instance.firingPlayersCutsceneRunning ? ShipStatus.Fired : (instance.shipIsLeaving ? ShipStatus.Leaving : (instance.beganLoadingNewLevel ? ShipStatus.Landing : ((!instance.inShipPhase) ? ((!instance.currentLevel.planetHasTime && instance.currentLevel.riskLevel.Equals("Safe")) ? ShipStatus.Selling : ShipStatus.Landed) : ShipStatus.Orbiting))));
return new LobbyStatus(shipStatus, currentMoon, connectedPlayers, valueOrDefault2);
}
private static LobbyOwner GetCurrentLobbyOwner()
{
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
string name = GameNetworkManager.Instance.localPlayerController?.playerUsername ?? "unknown";
string id = GameNetworkManager.Instance.localPlayerController?.playerSteamId.ToString() ?? string.Empty;
DiscordController instance = DiscordController.Instance;
long? obj;
if (instance == null)
{
obj = null;
}
else
{
Discord discord = instance.discord;
if (discord == null)
{
obj = null;
}
else
{
UserManager userManager = discord.GetUserManager();
obj = ((userManager != null) ? new long?(userManager.GetCurrentUser().Id) : null);
}
}
long? num = obj;
long valueOrDefault = num.GetValueOrDefault();
return new LobbyOwner(name, id, valueOrDefault);
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "packsolite.lethalletdownbot";
public const string PLUGIN_NAME = "LethalLetdownBot";
public const string PLUGIN_VERSION = "1.1.0";
}
}
namespace LethalLetdownBot.Utils
{
internal static class LogHelper
{
public static void Info(string message)
{
LethalLetdownBot.Logger.LogInfo((object)message);
}
public static void Warn(string message)
{
LethalLetdownBot.Logger.LogWarning((object)message);
}
public static void Error(string message)
{
LethalLetdownBot.Logger.LogError((object)message);
}
public static void Error(Exception ex, string context = "Unhandled exception")
{
string text = ex?.GetBaseException().Message ?? "Unknown error";
LethalLetdownBot.Logger.LogError((object)(context + ": " + text));
}
public static void LogFaulted(Task task, string context)
{
if (task.IsFaulted)
{
string text = task.Exception?.GetBaseException().Message ?? "Unknown error";
LethalLetdownBot.Logger.LogError((object)(context + ": " + text));
}
}
}
public static class UserUtil
{
private static readonly string FilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "LethalLetdown", "user-secret.txt");
public static string GetOrCreateUserId()
{
if (File.Exists(FilePath))
{
return File.ReadAllText(FilePath).Trim();
}
string text = Guid.NewGuid().ToString();
Directory.CreateDirectory(Path.GetDirectoryName(FilePath));
File.WriteAllText(FilePath, text);
return text;
}
}
}
namespace LethalLetdownBot.Patches
{
[HarmonyPatch(typeof(StartOfRound))]
public class StartOfRoundPatch
{
[CompilerGenerated]
private sealed class <CreateLobbyDelayed>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CreateLobbyDelayed>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
{
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
}
LobbyManager.Instance.CreateLobby();
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[HarmonyPatch("Start")]
[HarmonyPrefix]
private static void OnCreateLobby(StartOfRound __instance)
{
if (((NetworkBehaviour)__instance).IsHost && LethalLetdownBot.Enabled)
{
((MonoBehaviour)__instance).StartCoroutine(CreateLobbyDelayed(__instance));
}
}
[HarmonyPatch("OnLocalDisconnect")]
[HarmonyPrefix]
private static void OnDestroyLobby(StartOfRound __instance)
{
if (((NetworkBehaviour)__instance).IsHost && LethalLetdownBot.Enabled)
{
LobbyManager.Instance.DeleteLobby();
}
}
[HarmonyPatch("StartGame")]
[HarmonyPostfix]
private static void OnStartGame(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("OnShipLandedMiscEvents")]
[HarmonyPostfix]
private static void OnShipLanded(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("ShipLeave")]
[HarmonyPostfix]
private static void OnShipLeave(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("SetShipReadyToLand")]
[HarmonyPostfix]
private static void OnUpdateDiscordStatus(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("FirePlayersAfterDeadlineClientRpc")]
[HarmonyPostfix]
private static void OnPlayersFired(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("OnClientConnect")]
[HarmonyPostfix]
private static void OnClientConnected(StartOfRound __instance)
{
UpdateStatus(__instance);
}
[HarmonyPatch("OnClientDisconnect")]
[HarmonyPostfix]
private static void OnClientDisconnected(StartOfRound __instance)
{
UpdateStatus(__instance);
}
private static void UpdateStatus(StartOfRound startOfRound)
{
LobbyManager.Instance.UpdateLobby();
}
[IteratorStateMachine(typeof(<CreateLobbyDelayed>d__10))]
private static IEnumerator CreateLobbyDelayed(StartOfRound __instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CreateLobbyDelayed>d__10(0);
}
}
}
namespace LethalLetdownBot.Client
{
public enum ShipStatus
{
Orbiting,
Landing,
Landed,
Leaving,
Selling,
Fired
}
public class CurrentMoon
{
public string Name { get; set; }
public string PlanetName { get; set; }
public string CurrentWeather { get; set; }
public string RiskLevel { get; set; }
public CurrentMoon()
{
}
public CurrentMoon(string name, string planetName, string currentWeather, string riskLevel)
{
Name = name;
PlanetName = planetName;
CurrentWeather = currentWeather;
RiskLevel = riskLevel;
}
public static CurrentMoon FromSelectableLevel(SelectableLevel level)
{
return new CurrentMoon(((Object)level).name, level.PlanetName, ((object)(LevelWeatherType)(ref level.currentWeather)).ToString(), level.riskLevel);
}
}
public class LobbyStatus
{
public ShipStatus ShipStatus { get; set; }
public CurrentMoon? CurrentMoon { get; set; }
public int PlayerCount { get; set; }
public int MaxPlayerCount { get; set; }
public LobbyStatus()
{
}
public LobbyStatus(ShipStatus shipStatus, CurrentMoon currentMoon, int playerCount, int maxPlayerCount)
{
ShipStatus = shipStatus;
CurrentMoon = currentMoon;
PlayerCount = playerCount;
MaxPlayerCount = maxPlayerCount;
}
}
public class LobbyOwner
{
public string Name { get; set; }
public string ID { get; set; }
public long DiscordId { get; set; }
public LobbyOwner()
{
}
public LobbyOwner(string name, string id, long discordId)
{
Name = name;
ID = id;
DiscordId = discordId;
}
}
public class Lobby
{
public LobbyStatus Status { get; set; }
public LobbyOwner Owner { get; set; }
}
internal class LobbyStatusUpdateRequest
{
public LobbyStatus Status { get; set; }
}
internal class LobbyCreateRequest
{
public string Token { get; set; }
public string Name { get; set; }
public string SteamLobby { get; set; }
public LobbyOwner Owner { get; set; }
public LobbyStatus Status { get; set; }
public bool IsPublic { get; set; }
}
internal class LobbyCreateResponse
{
public bool Successful { get; set; }
public string LobbyId { get; set; }
}
public class RestClient
{
private static readonly Lazy<RestClient> _instance = new Lazy<RestClient>(() => new RestClient());
private readonly HttpClient _httpClient = new HttpClient();
private string _lobbyId;
public static RestClient Instance => _instance.Value;
private RestClient()
{
StartHeartbeatTimer();
}
private void StartHeartbeatTimer()
{
Timer timer = new Timer(delegate
{
SendHeartbeat().ContinueWith(delegate(Task t)
{
LogHelper.LogFaulted(t, "Failed sending heartbeat");
});
}, null, TimeSpan.Zero, TimeSpan.FromMinutes(1.0));
}
public async Task SendHeartbeat()
{
if (_lobbyId != null)
{
await _httpClient.PostAsync(LethalLetdownBot.URL + "lobby/" + _lobbyId + "/heartbeat", new ByteArrayContent(new byte[0]));
}
}
public async Task CreateLobby(LobbyOwner owner, LobbyStatus status, string lobbyName, string steamLobbyId, bool isPublic)
{
LobbyCreateRequest lobbyCreateRequest = new LobbyCreateRequest
{
Token = LethalLetdownBot.Token,
Name = lobbyName,
SteamLobby = steamLobbyId,
Owner = owner,
Status = status,
IsPublic = isPublic
};
StringContent content = new StringContent(JsonConvert.SerializeObject((object)lobbyCreateRequest), Encoding.UTF8, "application/json");
HttpResponseMessage httpResponseMessage = await _httpClient.PostAsync(LethalLetdownBot.URL + "lobby", content);
if (!httpResponseMessage.IsSuccessStatusCode)
{
object arg = httpResponseMessage.StatusCode;
LogHelper.Error($"Failed to post: {arg} - {await httpResponseMessage.Content.ReadAsStringAsync()}");
return;
}
string text = await httpResponseMessage.Content.ReadAsStringAsync();
try
{
LobbyCreateResponse lobbyCreateResponse = JsonConvert.DeserializeObject<LobbyCreateResponse>(text);
if (lobbyCreateResponse == null || !lobbyCreateResponse.Successful)
{
LogHelper.Error("Failed to create lobby: " + (lobbyCreateResponse?.LobbyId ?? ("invalid response: " + text)));
return;
}
_lobbyId = lobbyCreateResponse.LobbyId;
LethalLetdownBot.Logger.LogInfo((object)("Successfully created lobby with id '" + _lobbyId + "'"));
}
catch (Exception ex)
{
LogHelper.Error(ex, "Failed deserializing response");
}
}
public async Task DestroyLobby()
{
if (_lobbyId == null)
{
LogHelper.Error("Could not delete lobby: _lobbyId is null");
return;
}
await _httpClient.DeleteAsync(LethalLetdownBot.URL + "lobby/" + _lobbyId);
LethalLetdownBot.Logger.LogInfo((object)("Successfully deleted lobby '" + _lobbyId + "'"));
_lobbyId = null;
}
public async Task UpdateLobbyStatus(LobbyStatus status)
{
if (_lobbyId == null)
{
LogHelper.Error("Could not update lobby status: _lobbyId is null");
return;
}
StringContent content = new StringContent(JsonConvert.SerializeObject((object)new LobbyStatusUpdateRequest
{
Status = status
}), Encoding.UTF8, "application/json");
HttpResponseMessage httpResponseMessage = await _httpClient.PutAsync(LethalLetdownBot.URL + "lobby/" + _lobbyId + "/status", content);
if (httpResponseMessage.IsSuccessStatusCode)
{
LogHelper.Info($"Successfully updated lobby (status={status.ShipStatus}, players={status.PlayerCount})");
return;
}
object arg = httpResponseMessage.StatusCode;
LogHelper.Error($"Failed to post: {arg} - {await httpResponseMessage.Content.ReadAsStringAsync()}");
}
}
}
