using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using PlayerKillCounter.Behaviours;
using PlayerKillCounter.Extensions;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PlayerKillCounter")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlayerKillCounter")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7B499935-0339-454A-860B-CB0D2650A230")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PlayerKillCounter
{
public interface ICausedBy
{
ulong GetCausingPlayerId();
}
[BepInPlugin("PlayerKillCounter", "Player Kill Counter", "0.0.2")]
public class Mod : BaseUnityPlugin
{
private static ManualLogSource _logger;
public static ManualLogSource Logger => _logger;
public void Awake()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
_logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Loading harmony...");
Harmony val = new Harmony(((object)this).GetType().FullName);
try
{
Type[] nestedTypes = typeof(Patches).GetNestedTypes();
foreach (Type type in nestedTypes)
{
if (type.IsClass && type.IsAbstract && type.IsSealed)
{
Logger.LogInfo((object)("Patching " + type.Name + "..."));
val.PatchAll(type);
}
}
}
catch (Exception ex)
{
Logger.LogError((object)("Failed to patch: " + ex));
}
}
}
public static class Patches
{
public static class StartOfRoundPatches
{
[HarmonyPatch(typeof(StartOfRound), "Start")]
[HarmonyPrefix]
public static bool Start_Pre(StartOfRound __instance)
{
if ((Object)(object)((Component)__instance).GetComponent<KillCounter>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<KillCounter>();
}
if ((Object)(object)((Component)__instance).GetComponent<RPCHandler>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<RPCHandler>();
}
return true;
}
[HarmonyPatch(typeof(StartOfRound), "Start")]
[HarmonyPostfix]
public static void Start_Post(StartOfRound __instance)
{
PlayerStats[] allPlayerStats = __instance.gameStats.allPlayerStats;
for (int i = 0; i < allPlayerStats.Length; i++)
{
allPlayerStats[i].playerNotes.Add("THIS IS DUMMY DATA");
}
}
[HarmonyPatch(typeof(StartOfRound), "WritePlayerNotes")]
[HarmonyPrefix]
public static bool WritePlayerNotes(StartOfRound __instance)
{
KillCounter component = ((Component)StartOfRound.Instance).GetComponent<KillCounter>();
Mod.Logger.LogInfo((object)$"killedByDict: [{component}]");
for (int i = 0; i < __instance.gameStats.allPlayerStats.Length; i++)
{
ulong playerClientId = __instance.allPlayerScripts[i].playerClientId;
if (component.ContainsPlayerClientId(playerClientId))
{
KillCounter.Info killedBy = component[playerClientId];
PlayerControllerB val = __instance.allPlayerScripts.First((PlayerControllerB player) => player.playerClientId == killedBy.KillerClientId);
__instance.gameStats.allPlayerStats[i].playerNotes.Add("Killed by " + (((Object)(object)val != (Object)null) ? val.playerUsername : "[UNKNOWN]") + " via '" + ((object)(CauseOfDeath)(ref killedBy.CauseOfDeath)).ToString() + "'");
}
}
component.Clear();
return true;
}
}
public static class LandminePatches
{
[HarmonyPatch(typeof(Landmine), "Start")]
[HarmonyPostfix]
public static void Start(Landmine __instance)
{
__instance.LogInfo("Landmine found!");
}
[HarmonyPatch(typeof(Landmine), "TriggerOtherMineDelayed")]
[HarmonyPrefix]
public static bool TriggerOtherMineDelayed(Landmine __instance, Landmine mine)
{
try
{
Mod.Logger.LogInfo((object)$"instance: {__instance}, mine: {mine}");
if (mine.hasExploded)
{
return true;
}
LandmineTriggeredBy component = ((Component)__instance).GetComponent<LandmineTriggeredBy>();
if ((Object)(object)component == (Object)null)
{
__instance.LogWarning("Landmine was triggered without the LandmineTriggeredBy behaviour being added!");
}
LandmineTriggeredBy landmineTriggeredBy = ((Component)mine).gameObject.GetComponent<LandmineTriggeredBy>();
if ((Object)(object)landmineTriggeredBy == (Object)null)
{
mine.LogWarning("No LandmineTriggeredBy behaviour on landmine!");
landmineTriggeredBy = ((Component)mine).gameObject.AddComponent<LandmineTriggeredBy>();
mine.LogWarning("Added LandmineTriggeredBy behaviour to landmine!");
}
__instance.LogInfo($"Setting clientIdTrigger on Landmine {mine}");
landmineTriggeredBy.TriggeredByClientId = component.TriggeredByClientId;
}
catch (Exception ex)
{
__instance.LogError($"Failed to run Landmine 'SpawnExplosion' Prefixes! {ex} {new StackTrace(ex)}");
}
return true;
}
[HarmonyPatch(typeof(Landmine), "ExplodeMineClientRpc")]
[HarmonyPrefix]
public static bool ExplodeMineClientRpc(Landmine __instance)
{
//IL_0006: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
try
{
IEnumerable<PlayerControllerB> killRadiusPlayers = GetKillRadiusPlayers(((Component)__instance).transform.position + Vector3.up);
__instance.LogInfo("Found [" + GeneralExtensions.Join<PlayerControllerB>(killRadiusPlayers, (Func<PlayerControllerB, string>)((PlayerControllerB o) => o.playerUsername), ", ") + "] players in landmine radius");
LandmineTriggeredBy landmineTriggeredBy = ((Component)__instance).GetComponent<LandmineTriggeredBy>();
if ((Object)(object)landmineTriggeredBy == (Object)null)
{
__instance.LogWarning("No LandmineTriggeredBy behaviour on landmine!");
landmineTriggeredBy = ((Component)__instance).gameObject.AddComponent<LandmineTriggeredBy>();
__instance.LogWarning("Added LandmineTriggeredBy behaviour to landmine!");
}
foreach (PlayerControllerB item in killRadiusPlayers)
{
__instance.LogInfo($"Player [{landmineTriggeredBy.TriggeredByClientId}] killed [{item.playerClientId}] via Landmine");
if (item.playerClientId == landmineTriggeredBy.TriggeredByClientId)
{
__instance.LogInfo($"Player [{landmineTriggeredBy.TriggeredByClientId}] killed themselves via Landmine, not noteworthy.");
continue;
}
KillCounter component = ((Component)StartOfRound.Instance).GetComponent<KillCounter>();
if (!component.ContainsPlayerClientId(item.playerClientId))
{
component.Add(item.playerClientId, new KillCounter.Info
{
KillerClientId = landmineTriggeredBy.TriggeredByClientId,
CauseOfDeath = (CauseOfDeath)3
});
}
}
}
catch (Exception ex)
{
__instance.LogError($"Failed to run Landmine 'ExplodeMineClientRpc' Prefixes! {ex} {new StackTrace(ex)}");
}
return true;
}
[HarmonyPatch(typeof(Landmine), "OnTriggerExit")]
[HarmonyPrefix]
public static bool OnTriggerExit(Landmine __instance, Collider other)
{
try
{
if (__instance.hasExploded)
{
return true;
}
if (((Component)other).CompareTag("Player"))
{
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
__instance.LogInfo($"Found Player {component.playerUsername} ({component.playerClientId})!");
((Component)__instance).gameObject.GetComponent<LandmineTriggeredBy>().TriggeredByClientId = component.playerClientId;
}
else
{
__instance.LogInfo("Failed to find Player!");
}
}
catch (Exception ex)
{
__instance.LogError($"Failed to run Landmine 'OnTriggerExit' Prefixes! {ex} {new StackTrace(ex)}");
}
return true;
}
[HarmonyPatch(typeof(Landmine), "IHittable.Hit")]
[HarmonyPrefix]
public static bool IHittable_Hit(Landmine __instance, int force, Vector3 hitDirection, PlayerControllerB playerWhoHit, bool playHitSFX)
{
try
{
__instance.LogInfo($"Player [{playerWhoHit.playerClientId}] triggered Landmine");
LandmineTriggeredBy landmineTriggeredBy = ((Component)__instance).GetComponent<LandmineTriggeredBy>();
if ((Object)(object)landmineTriggeredBy == (Object)null)
{
__instance.LogWarning("No LandmineTriggeredBy behaviour on landmine!");
landmineTriggeredBy = ((Component)__instance).gameObject.AddComponent<LandmineTriggeredBy>();
__instance.LogWarning("Added LandmineTriggeredBy behaviour to landmine!");
}
landmineTriggeredBy.TriggeredByClientId = playerWhoHit.playerClientId;
}
catch (Exception ex)
{
__instance.LogError($"Failed to run Landmine 'OnTriggerExit' Prefixes! {ex} {new StackTrace(ex)}");
}
return true;
}
private static bool PositionWithinExplosionRange(Vector3 explosionPos, Vector3 targetPos)
{
//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_0002: Unknown result type (might be due to invalid IL or missing references)
//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)
return Physics.Linecast(explosionPos, targetPos + Vector3.up * 0.3f, 256, (QueryTriggerInteraction)1);
}
private static IEnumerable<PlayerControllerB> GetKillRadiusPlayers(Vector3 explosionPosition)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Physics.OverlapSphere(explosionPosition, 6f, 2621448, (QueryTriggerInteraction)2);
Collider[] array2 = array;
foreach (Collider val in array2)
{
if (((double)Vector3.Distance(explosionPosition, ((Component)val).transform.position) <= 4.0 || PositionWithinExplosionRange(explosionPosition, ((Component)val).transform.position)) && ((Component)val).gameObject.layer == 3)
{
yield return ((Component)val).gameObject.GetComponent<PlayerControllerB>();
}
}
}
}
public static class PlayerControllerBPatches
{
[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayerFromOtherClientClientRpc")]
[HarmonyPrefix]
public static void DamagePlayerFromOtherClientClientRpc(PlayerControllerB __instance, int damageAmount, Vector3 hitDirection, int playerWhoHit, int newHealthAmount)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (newHealthAmount <= 0)
{
KillCounter.Instance.Add(__instance.playerClientId, new KillCounter.Info
{
KillerClientId = (ulong)playerWhoHit,
CauseOfDeath = (CauseOfDeath)1
});
}
}
}
}
public static class Statics
{
public const string GUID = "PlayerKillCounter";
public const string NAME = "Player Kill Counter";
public const string VERSION = "0.0.2";
public const uint NETWORK_ID = 100000u;
}
}
namespace PlayerKillCounter.Extensions
{
public static class LandmineExtensions
{
public static void Log(this Landmine landmine, LogLevel level, string msg)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = Vector3.negativeInfinity;
if ((Object)(object)landmine != (Object)null)
{
val = ((Component)landmine).transform.position;
}
Mod.Logger.Log(level, (object)($"[Landmine @ {val}] " + msg));
}
public static void LogFatal(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)1, msg);
}
public static void LogError(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)2, msg);
}
public static void LogWarning(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)4, msg);
}
public static void LogMessage(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)8, msg);
}
public static void LogInfo(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)16, msg);
}
public static void LogDebug(this Landmine landmine, string msg)
{
landmine.Log((LogLevel)32, msg);
}
}
}
namespace PlayerKillCounter.Behaviours
{
public class KillCounter : MonoBehaviour
{
public struct Info
{
public ulong KillerClientId;
public CauseOfDeath CauseOfDeath;
public byte[] Encode()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected I4, but got Unknown
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(1024, (Allocator)2, 12);
BytePacker.WriteValueBitPacked(val, KillerClientId);
BytePacker.WriteValueBitPacked(val, (uint)(int)CauseOfDeath);
return ((FastBufferWriter)(ref val)).ToArray();
}
public Info Decode(byte[] data)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: 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)
FastBufferReader val = new FastBufferReader(data, (Allocator)2, -1, 0);
ByteUnpacker.ReadValueBitPacked(val, ref KillerClientId);
uint num = default(uint);
ByteUnpacker.ReadValueBitPacked(val, ref num);
try
{
CauseOfDeath = (CauseOfDeath)num;
}
catch (InvalidCastException)
{
Mod.Logger.LogError((object)$"Unknown CauseOfDeath Id {num}");
CauseOfDeath = (CauseOfDeath)0;
}
return this;
}
}
private static KillCounter _instance;
public static KillCounter Instance => _instance;
private Dictionary<ulong, Info> KilledBy { get; set; }
public Info this[ulong targetPlayerClientId] => KilledBy[targetPlayerClientId];
public void Start()
{
_instance = this;
KilledBy = new Dictionary<ulong, Info>();
}
public void Add(ulong targetPlayerClientId, Info info, bool broadcast = true)
{
if (broadcast)
{
RPCHandler.Instance.Send(RPCHandler.Action.UPDATE_KILL_COUNTER, targetPlayerClientId, info.Encode());
}
KilledBy.Add(targetPlayerClientId, info);
}
public bool ContainsPlayerClientId(ulong targetPlayerClientId)
{
return KilledBy.ContainsKey(targetPlayerClientId);
}
public void Clear()
{
KilledBy.Clear();
}
public override string ToString()
{
return GeneralExtensions.Join<ulong>((IEnumerable<ulong>)KilledBy.Keys, (Func<ulong, string>)((ulong o) => o.ToString()), ", ");
}
}
public class LandmineTriggeredBy : MonoBehaviour, ICausedBy
{
public ulong TriggeredByClientId { get; set; }
public ulong GetCausingPlayerId()
{
return TriggeredByClientId;
}
}
public class RPCHandler : NetworkBehaviour
{
public enum Direction
{
UNKNOWN,
TO_SERVER,
TO_CLIENT
}
public enum Action
{
UNKNOWN,
UPDATE_KILL_COUNTER
}
private static RPCHandler _instance;
public static RPCHandler Instance => _instance;
private bool IsClient
{
get
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
if ((int)base.__rpc_exec_stage != 2)
{
if (!((NetworkBehaviour)this).NetworkManager.IsServer)
{
return ((NetworkBehaviour)this).NetworkManager.IsHost;
}
return true;
}
return false;
}
}
private bool IsServer
{
get
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
if ((int)base.__rpc_exec_stage != 1)
{
if (!((NetworkBehaviour)this).NetworkManager.IsClient)
{
return ((NetworkBehaviour)this).NetworkManager.IsHost;
}
return true;
}
return false;
}
}
public void Send(Action action, params object[] args)
{
if (action == Action.UNKNOWN)
{
throw new ArgumentException("UNKNOWN passed as the action!", "action");
}
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening)
{
if (IsClient)
{
SendToServer(action, args);
}
else if (IsServer)
{
SendToClient(action, args);
}
}
}
private void SendToServer(Action action, params object[] args)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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_0080: Unknown result type (might be due to invalid IL or missing references)
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(100000u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, 1u);
BytePacker.WriteValueBitPacked(val2, (uint)action);
if (action == Action.UPDATE_KILL_COUNTER && args.Length == 2)
{
ulong num = (ulong)args[0];
byte[] array = (byte[])args[1];
BytePacker.WriteValueBitPacked(val2, num);
BytePacker.WriteValueBitPacked(val2, array.Length);
((FastBufferWriter)(ref val2)).WriteBytes(array, -1, 0);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 100000u, val, (RpcDelivery)0);
}
else
{
Mod.Logger.LogError((object)$"Unknown combination of {action} and {args}");
}
}
private void SendToClient(Action action, params object[] args)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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_0080: Unknown result type (might be due to invalid IL or missing references)
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(100000u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, 2u);
BytePacker.WriteValueBitPacked(val2, (uint)action);
if (action == Action.UPDATE_KILL_COUNTER && args.Length == 2)
{
ulong num = (ulong)args[0];
byte[] array = (byte[])args[1];
BytePacker.WriteValueBitPacked(val2, num);
BytePacker.WriteValueBitPacked(val2, array.Length);
((FastBufferWriter)(ref val2)).WriteBytes(array, -1, 0);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 100000u, val, (RpcDelivery)0);
}
else
{
Mod.Logger.LogError((object)$"Unknown combination of {action} and {args}");
}
}
public void Awake()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
_instance = this;
NetworkManager.__rpc_func_table.Add(100000u, new RpcReceiveHandler(RPCReceiveHandler));
}
private void RPCReceiveHandler(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002a: 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)
NetworkManager networkManager = target.NetworkManager;
if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening && ReadHeader(ref reader, out var direction, out var action))
{
HandleAction(target, reader, rpcParams, direction, action);
}
}
private bool ReadHeader(ref FastBufferReader reader, out Direction direction, out Action action)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
uint num = default(uint);
ByteUnpacker.ReadValueBitPacked(reader, ref num);
try
{
direction = (Direction)num;
}
catch (InvalidCastException)
{
Mod.Logger.LogError((object)$"Unknown message direction {num}");
direction = Direction.UNKNOWN;
action = Action.UNKNOWN;
return false;
}
uint num2 = default(uint);
ByteUnpacker.ReadValueBitPacked(reader, ref num2);
try
{
action = (Action)num2;
}
catch (InvalidCastException)
{
Mod.Logger.LogError((object)$"Unknown action id {num2}");
action = Action.UNKNOWN;
return false;
}
return true;
}
private void HandleAction(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams, Direction direction, Action action)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (IsClient && direction == Direction.TO_CLIENT)
{
HandleClientAction(target, reader, rpcParams, action);
}
else if (IsServer && direction == Direction.TO_SERVER)
{
HandleServerAction(target, reader, rpcParams, action);
}
}
private void HandleClientAction(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams, Action action)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (action == Action.UPDATE_KILL_COUNTER)
{
ulong targetPlayerClientId = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref targetPlayerClientId);
if (!KillCounter.Instance.ContainsPlayerClientId(targetPlayerClientId))
{
int num = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref num);
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytes(ref data, num, 0);
KillCounter.Info info = default(KillCounter.Info).Decode(data);
KillCounter.Instance.Add(targetPlayerClientId, info, broadcast: false);
}
}
}
private void HandleServerAction(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams, Action action)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(100000u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, 2u);
BytePacker.WriteValueBitPacked(val2, (uint)action);
((FastBufferWriter)(ref val2)).WriteBytes(((FastBufferReader)(ref reader)).ToArray(), -1, 0);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 100000u, val, (RpcDelivery)0);
}
}
}
