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 BepInEx;
using BepInEx.Configuration;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using LC_API.GameInterfaceAPI.Features;
using Microsoft.CodeAnalysis;
using Network;
using ScreamCounter;
using TMPro;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ScreamCounter")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("YourModDescriptionGoesHere")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9cde83bf2a79cd4ad0f2ec7070215edb39dd3be6")]
[assembly: AssemblyProduct("ScreamCounter")]
[assembly: AssemblyTitle("ScreamCounter")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
static <Module>()
{
}
}
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 ScreamCounter
{
[BepInPlugin("frsk.Scream_Counter", "ScreamCounter", "1.0.0")]
public class ScreamCounter : BaseUnityPlugin
{
[HarmonyPatch(typeof(GameNetworkManager))]
internal class GameNetworkManagerPatch
{
[HarmonyPatch("SaveGameValues")]
[HarmonyPostfix]
private static void SaveGameValuesPatch(ref GameNetworkManager __instance)
{
if (__instance.isHostingGame && StartOfRound.Instance.inShipPhase)
{
ES3.Save<int>("Stats_ScreamCounter", screamCounter, __instance.currentSaveFileName);
Debug.Log((object)"Scream Counter Successfully saved. Current value is: ");
}
}
[HarmonyPatch("ResetSaveGameValues")]
private static void ResetSaveGameValuesPatch(ref GameNetworkManager _instance)
{
if (_instance.isHostingGame)
{
screamCounter = 0;
ES3.Save<int>("Stats_ScreamCounter", 0, _instance.currentSaveFileName);
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundPatch
{
[HarmonyPatch("SetTimeAndPlanetToSavedSettings")]
[HarmonyPostfix]
private static void SetTimeAndPlanetToSavedSettingsPatchServerRpc(ref StartOfRound __instance)
{
string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
if (ES3.KeyExists("Stats_ScreamCounter"))
{
screamCounter = ES3.Load<int>("Stats_ScreamCounter", currentSaveFileName, 0);
Debug.Log((object)("Scream Counter Successfully loaded. Current value is: " + screamCounter));
}
}
[HarmonyPatch("DetectVoiceChatAmplitude")]
[HarmonyPostfix]
private static void DetectVoiceChatAmplitudePatch(ref StartOfRound __instance)
{
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if ((Object)(object)localPlayerController == (Object)null)
{
throw new Exception("pc is null");
}
float value = Traverse.Create((object)__instance).Field<float>("voiceChatNoiseCooldown").Value;
VoicePlayerState val = __instance.voiceChatModule.FindPlayer(__instance.voiceChatModule.LocalPlayerName);
bool flag = false;
float num = val.Amplitude / Mathf.Clamp(__instance.averageVoiceAmplitude, 0.008f, 0.5f);
if (!val.IsSpeaking || !(averageDetectCooldown <= 0f) || !(num > 3f))
{
flag = true;
}
if (averageCount > 5 && !localPlayerController.isPlayerDead && __instance.shipHasLanded && screamCooldown <= 0f)
{
if (val.Amplitude / averageSpeechAmplitude > screamFromAveragePercentage.Value)
{
CustomNetworkHandler.Instance.AddToScreamCounterServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)localPlayerController));
screamCooldown = 10f;
flag = true;
}
}
else if (screamCooldown > 0f)
{
screamCooldown -= Time.deltaTime;
}
if (!flag)
{
averageCount++;
totalSpeechAmplitude += val.Amplitude;
averageSpeechAmplitude = totalSpeechAmplitude / (float)averageCount;
Debug.Log((object)("Added amplitude to average. Current average: " + averageSpeechAmplitude));
averageDetectCooldown = 2f;
}
averageDetectCooldown -= Time.deltaTime;
}
[HarmonyPatch("WritePlayerNotes")]
[HarmonyPostfix]
private static void WritePlayerNotesPatch(ref StartOfRound __instance)
{
IOrderedEnumerable<KeyValuePair<PlayerControllerB, int>> source = currentPerPlayerScreams.OrderByDescending(delegate(KeyValuePair<PlayerControllerB, int> entry)
{
KeyValuePair<PlayerControllerB, int> keyValuePair = entry;
return keyValuePair.Value;
});
PlayerControllerB key = source.FirstOrDefault().Key;
if (source.FirstOrDefault().Value > 2)
{
__instance.gameStats.allPlayerStats[key.playerClientId].playerNotes.Add("Screamed the most");
}
}
[HarmonyPatch("EndGameServerRpc")]
[HarmonyPostfix]
private static void EndGameServerRpc(ref StartOfRound __instance)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
NetworkBehaviourReference[] array = (NetworkBehaviourReference[])(object)new NetworkBehaviourReference[currentPerPlayerScreams.Count];
for (int i = 0; i < array.Length; i++)
{
array[i] = new NetworkBehaviourReference((NetworkBehaviour)(object)currentPerPlayerScreams.Keys.ToArray()[i]);
}
int[] values = currentPerPlayerScreams.Values.ToArray();
CustomNetworkHandler.Instance.SendRoundScreamStatsClientRpc(array, values);
}
[HarmonyPatch("FirePlayersAfterDeadlineClientRpc")]
[HarmonyPostfix]
private static void FirePlayersAfterDeadlineClientRpcPatch(ref StartOfRound __instance, int[] endGameStats)
{
((TMP_Text)HUDManager.Instance.EndOfRunStatsText).text = $"Days on the job: {endGameStats[0]}\n" + $"Scrap value collected: {endGameStats[1]}\n" + $"Deaths: {endGameStats[2]}\n" + $"Steps taken: {endGameStats[3] + $"\nScreams: {endGameStats[4]}"}";
screamCounter = 0;
}
[HarmonyPatch("ResetStats")]
[HarmonyPostfix]
private static void ResetStatsPatch()
{
currentPerPlayerScreams.Clear();
}
[HarmonyPatch("Start")]
[HarmonyPrefix]
private static void StartResetCounter(ref StartOfRound __instance)
{
if (((NetworkBehaviour)__instance).IsServer)
{
screamCounter = 0;
}
}
[HarmonyPatch("GetEndgameStatsInOrder")]
[HarmonyPrefix]
private static bool GetEndgameStatsInOrderPatch(ref StartOfRound __instance, ref int[] __result)
{
__result = new int[5]
{
__instance.gameStats.daysSpent,
__instance.gameStats.scrapValueCollected,
__instance.gameStats.deaths,
__instance.gameStats.allStepsTaken,
screamCounter
};
return false;
}
}
private const string modGUID = "frsk.Scream_Counter";
private const string modName = "ScreamCounter";
private const string modVersion = "1.0.0";
public static ConfigEntry<float> screamFromAveragePercentage;
private Harmony harmony = new Harmony("frsk.Scream_Counter");
public static ScreamCounter Instance;
public static int screamCounter = 0;
public static int averageCount = 0;
public static float averageSpeechAmplitude;
public static float totalSpeechAmplitude;
public static int currentPlayerCheck = 0;
public static float screamCooldown = 0f;
public static float averageDetectCooldown = 0f;
public static bool corRunning = false;
public static Dictionary<PlayerControllerB, int> currentPerPlayerScreams = new Dictionary<PlayerControllerB, int>();
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
screamFromAveragePercentage = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ScreamFromAveragePercentage", 1.5f, "");
int[] array = new int[0];
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin frsk.Scream_Counter is loaded!");
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array2 = types;
foreach (Type type in array2)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array3 = methods;
foreach (MethodInfo methodInfo in array3)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
harmony.PatchAll();
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "ScreamCounter";
public const string PLUGIN_NAME = "ScreamCounter";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace Network
{
[HarmonyPatch(typeof(Player))]
public class PlayerPatch
{
private static readonly string BUNDLE_PATH = Path.Combine(Paths.PluginPath, "2018-LC_API", "Bundles", "networking");
private const string PLAYER_NETWORKING_ASSET_LOCATION = "assets/lc_api/playernetworkingprefab.prefab";
private static GameObject networkPrefab;
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
[HarmonyPostfix]
[HarmonyPriority(1)]
public static void Init()
{
GameObject value = Traverse.Create(typeof(Player)).Property("PlayerNetworkPrefab", (object[])null).GetValue<GameObject>();
value.AddComponent<CustomNetworkHandler>();
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
public static void Init(ref Player __instance)
{
}
}
public class CustomNetworkHandler : NetworkBehaviour
{
public static CustomNetworkHandler Instance { get; private set; }
public override void OnNetworkSpawn()
{
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ClientRpc]
public void SendRoundScreamStatsClientRpc(NetworkBehaviourReference[] controllers, int[] values)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(388944433u, val, (RpcDelivery)0);
bool flag = controllers != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(controllers, default(ForNetworkSerializable));
}
bool flag2 = values != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
if (flag2)
{
((FastBufferWriter)(ref val2)).WriteValueSafe<int>(values, default(ForPrimitives));
}
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 388944433u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
PlayerControllerB key = default(PlayerControllerB);
for (int i = 0; i < controllers.Length; i++)
{
((NetworkBehaviourReference)(ref controllers[i])).TryGet<PlayerControllerB>(ref key, (NetworkManager)null);
global::ScreamCounter.ScreamCounter.currentPerPlayerScreams[key] = values[i];
}
}
}
[ServerRpc(RequireOwnership = false)]
public void AddToScreamCounterServerRpc(NetworkBehaviourReference playerref)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(76070574u, val, (RpcDelivery)0);
((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref playerref, default(ForNetworkSerializable));
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 76070574u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
PlayerControllerB val3 = default(PlayerControllerB);
((NetworkBehaviourReference)(ref playerref)).TryGet<PlayerControllerB>(ref val3, (NetworkManager)null);
if (global::ScreamCounter.ScreamCounter.currentPerPlayerScreams.ContainsKey(val3))
{
global::ScreamCounter.ScreamCounter.currentPerPlayerScreams[val3] = global::ScreamCounter.ScreamCounter.currentPerPlayerScreams[val3] + 1;
}
else
{
global::ScreamCounter.ScreamCounter.currentPerPlayerScreams[val3] = 1;
}
if (global::ScreamCounter.ScreamCounter.screamCooldown <= 0f)
{
global::ScreamCounter.ScreamCounter.screamCounter++;
global::ScreamCounter.ScreamCounter.screamCooldown = 10f;
}
else
{
global::ScreamCounter.ScreamCounter.screamCooldown -= Time.deltaTime;
}
Debug.Log((object)$"player {((Object)val3).name} added to scream counter. His counter: {global::ScreamCounter.ScreamCounter.currentPerPlayerScreams[val3]}, General: {global::ScreamCounter.ScreamCounter.screamCounter}");
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_CustomNetworkHandler()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(388944433u, new RpcReceiveHandler(__rpc_handler_388944433));
NetworkManager.__rpc_func_table.Add(76070574u, new RpcReceiveHandler(__rpc_handler_76070574));
}
private static void __rpc_handler_388944433(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//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_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: 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_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
bool flag = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
NetworkBehaviourReference[] controllers = null;
if (flag)
{
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref controllers, default(ForNetworkSerializable));
}
bool flag2 = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
int[] values = null;
if (flag2)
{
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref values, default(ForPrimitives));
}
target.__rpc_exec_stage = (__RpcExecStage)2;
((CustomNetworkHandler)(object)target).SendRoundScreamStatsClientRpc(controllers, values);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_76070574(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//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_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
NetworkBehaviourReference playerref = default(NetworkBehaviourReference);
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref playerref, default(ForNetworkSerializable));
target.__rpc_exec_stage = (__RpcExecStage)1;
((CustomNetworkHandler)(object)target).AddToScreamCounterServerRpc(playerref);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "CustomNetworkHandler";
}
}
}
