using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;
using com.github.zehsteam.Hitmarker.MonoBehaviours;
using com.github.zehsteam.Hitmarker.Patches;
[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("com.github.zehsteam.Hitmarker")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Shows a hitmarker when you successfully hit an enemy. With additional features. (Client-side)")]
[assembly: AssemblyFileVersion("1.2.3.0")]
[assembly: AssemblyInformationalVersion("1.2.3+9f550c00a965039c6c13c3bda8cf3750925b11f7")]
[assembly: AssemblyProduct("Hitmarker")]
[assembly: AssemblyTitle("com.github.zehsteam.Hitmarker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.3.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.zehsteam.Hitmarker
{
internal class ConfigManager
{
public ConfigEntry<bool> ExtendedLogging { get; private set; }
public ConfigEntry<bool> ShowHitmarkerImage { get; private set; }
public ConfigEntry<int> HitmarkerImageSize { get; private set; }
public ConfigEntry<bool> PlayHitmarkerSound { get; private set; }
public ConfigEntry<float> MessageDuration { get; private set; }
public ConfigEntry<int> MessageFontSize { get; private set; }
public ConfigEntry<bool> ShowDamageMessage { get; private set; }
public ConfigEntry<bool> ShowKillMessage { get; private set; }
public ConfigEntry<bool> OnlyShowLocalKillMessage { get; private set; }
public ConfigManager()
{
BindConfigs();
ClearUnusedEntries();
}
private void BindConfigs()
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
ExtendedLogging = config.Bind<bool>("General Settings", "ExtendedLogging", false, "Enable extended logging.");
ShowHitmarkerImage = config.Bind<bool>("Hitmarker Settings", "ShowHitmarkerImage", true, "Do you want to show the hitmarker image?");
HitmarkerImageSize = config.Bind<int>("Hitmarker Settings", "HitmarkerImageSize", 40, new ConfigDescription("The size of the hitmarker image in pixels.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 100), Array.Empty<object>()));
PlayHitmarkerSound = config.Bind<bool>("Hitmarker Settings", "PlayHitmarkerSound", true, "Do you want to play the hitmarker sound?");
MessageDuration = config.Bind<float>("Message Settings", "MessageDuration", 4f, "The message duration in seconds.");
MessageFontSize = config.Bind<int>("Message Settings", "MessageFontSize", 35, new ConfigDescription("The message font size in pixels.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 100), Array.Empty<object>()));
ShowDamageMessage = config.Bind<bool>("Message Settings", "ShowDamageMessage", true, "Shows a message of how much damage you did to an enemy.");
ShowKillMessage = config.Bind<bool>("Message Settings", "ShowKillMessage", true, "Shows a message when an enemy is killed.");
OnlyShowLocalKillMessage = config.Bind<bool>("Message Settings", "OnlyShowLocalKillMessage", true, "Will only show your kill messages.");
}
private void ClearUnusedEntries()
{
ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
dictionary.Clear();
config.Save();
}
}
internal class Content
{
public static GameObject HitmarkerCanvasPrefab;
public static void Load()
{
LoadAssetsFromAssetBundle();
}
private static void LoadAssetsFromAssetBundle()
{
try
{
string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
string text = Path.Combine(directoryName, "hitmarker_assets");
AssetBundle val = AssetBundle.LoadFromFile(text);
HitmarkerCanvasPrefab = val.LoadAsset<GameObject>("HitmarkerCanvas");
Plugin.logger.LogInfo((object)"Successfully loaded assets from AssetBundle!");
}
catch (Exception arg)
{
Plugin.logger.LogError((object)$"Error: failed to load assets from AssetBundle.\n\n{arg}");
}
}
}
[BepInPlugin("com.github.zehsteam.Hitmarker", "Hitmarker", "1.2.3")]
internal class Plugin : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("com.github.zehsteam.Hitmarker");
internal static Plugin Instance;
internal static ManualLogSource logger;
internal static ConfigManager ConfigManager;
internal static bool IsHostOrServer => NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
logger = Logger.CreateLogSource("com.github.zehsteam.Hitmarker");
logger.LogInfo((object)"Hitmarker has awoken!");
harmony.PatchAll(typeof(HUDManagerPatch));
harmony.PatchAll(typeof(EnemyAIPatch));
ConfigManager = new ConfigManager();
Content.Load();
}
public void CreateHitmarkerCanvas()
{
if (!((Object)(object)HitmarkerCanvasBehaviour.Instance != (Object)null))
{
Object.Instantiate<GameObject>(Content.HitmarkerCanvasPrefab);
logger.LogInfo((object)"Instantiated Hitmarker canvas.");
}
}
public void LogInfoExtended(object data)
{
if (ConfigManager.ExtendedLogging.Value)
{
logger.LogInfo(data);
}
}
}
internal class Utils
{
public static bool IsLocalPlayer(PlayerControllerB playerScript)
{
return (Object)(object)StartOfRound.Instance.localPlayerController == (Object)(object)playerScript;
}
public static PlayerControllerB GetPlayerScript(int playerWhoHit)
{
if (playerWhoHit < 0 || playerWhoHit > StartOfRound.Instance.allPlayerScripts.Length - 1)
{
return null;
}
return StartOfRound.Instance.allPlayerScripts[playerWhoHit];
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.github.zehsteam.Hitmarker";
public const string PLUGIN_NAME = "Hitmarker";
public const string PLUGIN_VERSION = "1.2.3";
}
}
namespace com.github.zehsteam.Hitmarker.Patches
{
[HarmonyPatch(typeof(EnemyAI))]
internal class EnemyAIPatch
{
[HarmonyPatch("HitEnemyOnLocalClient")]
[HarmonyPrefix]
private static void HitEnemyOnLocalClientPatch(ref EnemyAI __instance, int force, PlayerControllerB playerWhoHit = null)
{
if (!((Object)(object)playerWhoHit == (Object)null) && Utils.IsLocalPlayer(playerWhoHit))
{
HitEnemy(__instance, force, playerWhoHit);
}
}
[HarmonyPatch("HitEnemyServerRpc")]
[HarmonyPrefix]
private static void HitEnemyServerRpcPatch(ref EnemyAI __instance, int force, int playerWhoHit)
{
if (playerWhoHit != -1)
{
PlayerControllerB playerScript = Utils.GetPlayerScript(playerWhoHit);
if (!Utils.IsLocalPlayer(playerScript))
{
HitEnemy(__instance, force, playerScript);
}
}
}
[HarmonyPatch("HitEnemyClientRpc")]
[HarmonyPrefix]
private static void HitEnemyClientRpcPatch(ref EnemyAI __instance, int force, int playerWhoHit)
{
if (playerWhoHit != -1 && !Plugin.IsHostOrServer)
{
PlayerControllerB playerScript = Utils.GetPlayerScript(playerWhoHit);
if (!Utils.IsLocalPlayer(playerScript))
{
HitEnemy(__instance, force, playerScript);
}
}
}
private static void HitEnemy(EnemyAI enemyAI, int force, PlayerControllerB playerWhoHit)
{
if (enemyAI.enemyType.canDie && !enemyAI.isEnemyDead && enemyAI.enemyHP > 0)
{
bool flag = Utils.IsLocalPlayer(playerWhoHit);
string enemyName = enemyAI.enemyType.enemyName;
bool flag2 = enemyAI.enemyHP - force <= 0;
if (flag)
{
HitmarkerCanvasBehaviour.Instance.ShowHitmarker(flag2);
HitmarkerCanvasBehaviour.Instance.ShowDamageMessage(enemyName, force);
}
if (flag2)
{
HitmarkerCanvasBehaviour.Instance.ShowKillMessage(enemyName, flag, playerWhoHit.playerUsername);
}
LogInfoExtended("HitEnemy();", enemyAI, force, playerWhoHit);
}
}
private static void LogInfoExtended(string functionName, EnemyAI enemyAI, int force, PlayerControllerB playerWhoHit)
{
NetworkObject component = ((Component)enemyAI).gameObject.GetComponent<NetworkObject>();
string text = (Utils.IsLocalPlayer(playerWhoHit) ? " (LOCAL)" : "");
string text2 = $"{functionName} NetworkObjectId: {component.NetworkObjectId}\n\n";
text2 += $"Player \"{playerWhoHit.playerUsername}\"{text} hit \"{enemyAI.enemyType.enemyName}\" for {force} force.\n";
text2 += $"isEnemyDead: {enemyAI.isEnemyDead}, enemyHP: {enemyAI.enemyHP}, (new enemyHP should be {enemyAI.enemyHP - force})\n";
Plugin.Instance.LogInfoExtended("\n\n" + text2.Trim() + "\n");
}
}
[HarmonyPatch(typeof(HUDManager))]
internal class HUDManagerPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartPatch()
{
Plugin.Instance.CreateHitmarkerCanvas();
}
}
}
namespace com.github.zehsteam.Hitmarker.MonoBehaviours
{
public class HitmarkerCanvasBehaviour : MonoBehaviour
{
public static HitmarkerCanvasBehaviour Instance;
public HitmarkerImageBehaviour HitmarkerImageBehaviour;
public AudioClip HitSFX;
public RectTransform MessageListTransform;
public RectTransform MessageItemPrefab;
private Queue<RectTransform> _messageItemPool = new Queue<RectTransform>();
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
}
private void Start()
{
InitializeMessageItemPool();
}
private void InitializeMessageItemPool()
{
_messageItemPool = new Queue<RectTransform>();
for (int i = 0; i < 20; i++)
{
RectTransform val = Object.Instantiate<RectTransform>(MessageItemPrefab, (Transform)(object)MessageListTransform);
((Component)val).gameObject.SetActive(false);
_messageItemPool.Enqueue(val);
}
}
public void ShowHitmarker(bool killed = false)
{
ShowHitmarkerImage(killed);
PlayHitSFX();
}
private void ShowHitmarkerImage(bool killed = false)
{
if (Plugin.ConfigManager.ShowHitmarkerImage.Value)
{
HitmarkerImageBehaviour.ShowImage(killed);
}
}
private void PlayHitSFX()
{
if (Plugin.ConfigManager.PlayHitmarkerSound.Value)
{
HUDManager.Instance.UIAudio.PlayOneShot(HitSFX);
}
}
public void ShowDamageMessage(string enemyName, int damage = 1)
{
if (Plugin.ConfigManager.ShowDamageMessage.Value)
{
ShowMessage($"{enemyName} -{damage} HP");
}
}
public void ShowKillMessage(string enemyName, bool fromLocalPlayer = true, string fromPlayerName = "")
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.ConfigManager.ShowKillMessage.Value && (fromLocalPlayer || !Plugin.ConfigManager.OnlyShowLocalKillMessage.Value))
{
if (!fromLocalPlayer)
{
ShowMessage(fromPlayerName + " Killed " + enemyName, Color.red);
}
else
{
ShowMessage("Killed " + enemyName, Color.red);
}
}
}
private void ShowMessage(string text)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
ShowMessage(text, Color.white);
}
private void ShowMessage(string text, Color color)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
SpawnMessageItemFromPool(text, color);
}
private RectTransform SpawnMessageItemFromPool(string text, Color color)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
if (_messageItemPool == null || _messageItemPool.Count == 0)
{
Plugin.logger.LogError((object)"Error: Failed to spawn message item from pool. Message item pool is either null or empty.");
return null;
}
RectTransform val = _messageItemPool.Dequeue();
((Component)val).gameObject.SetActive(true);
((Transform)val).SetAsLastSibling();
MessageItemBehaviour messageItemBehaviour = default(MessageItemBehaviour);
if (((Component)val).TryGetComponent<MessageItemBehaviour>(ref messageItemBehaviour))
{
messageItemBehaviour.SetText(text, color);
}
_messageItemPool.Enqueue(val);
return val;
}
}
public class HitmarkerImageBehaviour : MonoBehaviour
{
public Image Image;
public Color32 DefaultColor;
public Color32 KilledColor;
private Coroutine _fadeOutCoroutine;
private void Start()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
int value = Plugin.ConfigManager.HitmarkerImageSize.Value;
((Graphic)Image).rectTransform.sizeDelta = new Vector2((float)value, (float)value);
SetAlpha(0f);
}
public void ShowImage(bool killed = false)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
((Graphic)Image).color = Color32.op_Implicit(killed ? KilledColor : DefaultColor);
if (_fadeOutCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(_fadeOutCoroutine);
}
_fadeOutCoroutine = ((MonoBehaviour)this).StartCoroutine(FadeOut(0.25f));
}
private IEnumerator FadeOut(float duration)
{
SetAlpha(255f);
for (float timer = 0f; timer < duration; timer += Time.deltaTime)
{
float percent = 1f / duration * timer;
float alpha = 255f + -255f * percent;
SetAlpha(alpha);
yield return null;
}
SetAlpha(0f);
}
private void SetAlpha(float a)
{
//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_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
a = Mathf.Clamp(a, 0f, 255f);
Color32 val = Color32.op_Implicit(((Graphic)Image).color);
val.a = (byte)a;
((Graphic)Image).color = Color32.op_Implicit(val);
}
}
public class MessageItemBehaviour : MonoBehaviour
{
public TextMeshProUGUI TextUGUI;
private Coroutine _animationCoroutine;
private void Start()
{
((TMP_Text)TextUGUI).fontSize = Plugin.ConfigManager.MessageFontSize.Value;
}
private void OnEnable()
{
if (_animationCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(_animationCoroutine);
}
_animationCoroutine = ((MonoBehaviour)this).StartCoroutine(PlayAnimation());
}
private void OnDisable()
{
if (_animationCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(_animationCoroutine);
}
}
private IEnumerator PlayAnimation()
{
yield return (object)new WaitForSeconds(Plugin.ConfigManager.MessageDuration.Value);
float fadeOutDuration = 1f;
SetAlpha(255f);
for (float timer = 0f; timer < fadeOutDuration; timer += Time.deltaTime)
{
float percent = 1f / fadeOutDuration * timer;
float alpha = 255f + -255f * percent;
SetAlpha(alpha);
yield return null;
}
SetAlpha(0f);
yield return null;
((Component)this).gameObject.SetActive(false);
}
public void SetText(string text)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
SetText(text, Color.white);
}
public void SetText(string text, Color color)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
((TMP_Text)TextUGUI).text = text;
((Graphic)TextUGUI).color = color;
}
private void SetAlpha(float a)
{
//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_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
a = Mathf.Clamp(a, 0f, 255f);
Color32 val = Color32.op_Implicit(((Graphic)TextUGUI).color);
val.a = (byte)a;
((Graphic)TextUGUI).color = Color32.op_Implicit(val);
}
}
}
