using System;
using System.Collections;
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.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Netcode;
using UnityEngine;
using infiltratorMod.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("infiltratorMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("infiltratorMod")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("08de51c8-694e-4a4e-9cbf-d565d3fb11d3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace infiltratorMod
{
[BepInPlugin("EvilPlayer_Imposter.Tormad", "EvilPlayer_Imposter", "1.1.0")]
public class ModBase : BaseUnityPlugin
{
public const string modGUID = "EvilPlayer_Imposter.Tormad";
public const string modName = "EvilPlayer_Imposter";
public const string modVersion = "1.1.0";
private readonly Harmony harmony = new Harmony("EvilPlayer_Imposter.Tormad");
private static ModBase Instance;
internal ManualLogSource mls;
private ConfigEntry<float> movSpeed;
private ConfigEntry<float> carryWeight;
private ConfigEntry<int> health;
private ConfigEntry<float> transparency;
private ConfigEntry<float> sprintSpeed;
private ConfigEntry<float> hitDistance;
private ConfigEntry<int> attackForce;
private ConfigEntry<int> maxEnemies;
private ConfigEntry<bool> canFly;
private ConfigEntry<bool> canDrop;
private ConfigEntry<bool> canRegen;
private ConfigEntry<bool> canOpenDoors;
private ConfigEntry<bool> canUnlockDoors;
private ConfigEntry<bool> canInteractInShip;
private ConfigEntry<int> doorLockMax;
private ConfigEntry<bool> nightVision;
private ConfigEntry<float> hitCooldown;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("EvilPlayer_Imposter.Tormad");
mls.LogInfo((object)"!!The EVIL player mod started!!");
movSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "MovementSpeed", 2f, "Movement speed of the evil player. (normal player can move at 4.6 with 0 weight)");
carryWeight = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "CarryWeight", 2.5f, "Carry weight of the evil player. (will reduce sprint time)");
health = ((BaseUnityPlugin)this).Config.Bind<int>("EvilPlayer", "Health", 10, "Health of the evil player.");
transparency = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "Transparency", 0.1f, "Transparency of the evil player.");
sprintSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "SprintSpeed", 10f, "Sprint speed of the evil player.");
hitDistance = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "HitDistance", 1.2f, "Hit distance of the evil player.");
attackForce = ((BaseUnityPlugin)this).Config.Bind<int>("EvilPlayer", "AttackForce", 1, "Damage dealt by the evil player.");
maxEnemies = ((BaseUnityPlugin)this).Config.Bind<int>("EvilPlayer", "MaxEnemies", 0, "Max enemies put 0 if none (does not increase past vanilla amount).");
canFly = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanFly", true, "Can the evil player fly (jump on air).");
canDrop = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanDrop", true, "Can the evil player drop the clipboard. (allows switching of evil player only in ship)");
canRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanRegen", false, "Can regen of the evil player. (after being killed)");
canOpenDoors = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanOpenDoors", true, "Can the evil player open doors. (will not open doors that require a key)");
canUnlockDoors = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanUnlockDoors", true, "Can the evil player unlock doors. (will not require a key)");
doorLockMax = ((BaseUnityPlugin)this).Config.Bind<int>("EvilPlayer", "DoorLockMax", 1, "Max doors the evil player can lock.");
canInteractInShip = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "CanInteractInShip", false, "Can the evil player interact with things in the ship.");
nightVision = ((BaseUnityPlugin)this).Config.Bind<bool>("EvilPlayer", "NightVision", false, "Can the evil player see in the dark. (broken currently do nto enable)");
hitCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("EvilPlayer", "HitCooldown", 0.2f, "Can the evil player hit multiple times in a row. (broken currently do nto enable)");
movSpeed.SettingChanged += OnConfigChanged;
carryWeight.SettingChanged += OnConfigChanged;
health.SettingChanged += OnConfigChanged;
transparency.SettingChanged += OnConfigChanged;
sprintSpeed.SettingChanged += OnConfigChanged;
hitDistance.SettingChanged += OnConfigChanged;
attackForce.SettingChanged += OnConfigChanged;
maxEnemies.SettingChanged += OnConfigChanged;
canFly.SettingChanged += OnConfigChanged;
canDrop.SettingChanged += OnConfigChanged;
canRegen.SettingChanged += OnConfigChanged;
canOpenDoors.SettingChanged += OnConfigChanged;
canUnlockDoors.SettingChanged += OnConfigChanged;
doorLockMax.SettingChanged += OnConfigChanged;
canInteractInShip.SettingChanged += OnConfigChanged;
nightVision.SettingChanged += OnConfigChanged;
hitCooldown.SettingChanged += OnConfigChanged;
PlayerSelectorPatch.modBaseInstance = this;
ApplyConfig();
harmony.PatchAll();
}
public void ApplyConfig()
{
EvilPlayer.movSpeed = movSpeed.Value;
EvilPlayer.carryWeight = carryWeight.Value;
EvilPlayer.health = health.Value;
EvilPlayer.transparency = transparency.Value;
EvilPlayer.sprintSpeed = sprintSpeed.Value;
EvilPlayer.hitDistance = hitDistance.Value;
EvilPlayer.attackHitForce = attackForce.Value;
EvilPlayer.canFly = canFly.Value;
EvilPlayer.canDrop = canDrop.Value;
EvilPlayer.RegenHealth = canRegen.Value;
EvilPlayer.maxEnemy = maxEnemies.Value;
EvilPlayer.canOpenDoors = canOpenDoors.Value;
EvilPlayer.canUnlockDoors = canUnlockDoors.Value;
EvilPlayer.doorLockMax = doorLockMax.Value;
EvilPlayer.canInteractInShip = canInteractInShip.Value;
EvilPlayer.nightVision = nightVision.Value;
EvilPlayer.hitCooldown = hitCooldown.Value;
}
private void OnConfigChanged(object sender, EventArgs e)
{
ApplyConfig();
}
}
}
namespace infiltratorMod.Patches
{
public static class EvilPlayer
{
public static float startTime = Time.realtimeSinceStartup;
public static float startTime1 = Time.realtimeSinceStartup;
public static ulong evilPlayerId = 696969uL;
public static List<float> yRot = new List<float>();
public static bool shouldTP = false;
public static bool hasLanded = false;
public static float movSpeed;
public static float carryWeight = 2.5f;
public static float jumpForce = 2f;
public static float sprintSpeed;
public static float hitDistance = 1.5f;
public static int health = 100;
public static float transparency = 0.7f;
public static List<Vector3> positions = new List<Vector3>();
public static int ventIndex = 0;
public static bool shipPhase = true;
public static string currentMoon = "";
public static bool changedSkin = false;
public static int attackHitForce = 1;
public static bool RegenHealth = true;
public static bool canFly = true;
public static bool canDrop = false;
public static int maxEnemy = 0;
public static int EnemyCount = 0;
public static bool canOpenDoors = true;
public static bool canUnlockDoors = false;
public static int DoorsLocked = 0;
public static int doorLockMax = 1;
public static bool canInteractInShip = true;
public static Transform Playerpos;
public static bool nightVision = true;
public static float lastPlayerAngle = 0f;
public static float lastHitTime = 0f;
public static float hitCooldown;
public static bool ShipLeaving = false;
}
[HarmonyPatch(typeof(ClipboardItem))]
internal class PlayerSelectorPatch
{
private static ManualLogSource logger;
private static int attackMask;
public static ModBase modBaseInstance;
static PlayerSelectorPatch()
{
attackMask = 11012424;
logger = Logger.CreateLogSource("EvilPlayer_Imposter.Tormad");
}
[HarmonyPostfix]
[HarmonyPatch("EquipItem")]
private static void PostfixEquipItem(ClipboardItem __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)null)
{
logger.LogError((object)"PostfixEquipItem: __instance or playerHeldBy is null.");
return;
}
modBaseInstance.ApplyConfig();
EvilPlayer.evilPlayerId = ((GrabbableObject)__instance).playerHeldBy.playerClientId;
((GrabbableObject)__instance).playerHeldBy.health = EvilPlayer.health;
((GrabbableObject)__instance).playerHeldBy.carryWeight = EvilPlayer.carryWeight;
((GrabbableObject)__instance).playerHeldBy.grabDistance = 2f;
((GrabbableObject)__instance).playerHeldBy.movementSpeed = EvilPlayer.movSpeed;
logger.LogInfo((object)"!___Player ID___!");
logger.LogInfo((object)EvilPlayer.evilPlayerId.ToString());
logger.LogInfo((object)"!___Player ID___!");
EvilPlayer.changedSkin = false;
if (((NetworkBehaviour)__instance).IsOwner)
{
HUDManager.Instance.DisplayTip("To use the EVil players abilities:", "Press Q to teleport between vents, hit left click to attack players and spam space to float.", true, true, "LCTip_UseManual");
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(ClipboardItem), "ItemInteractLeftRight")]
private static bool preItemInteractLeftRight(ClipboardItem __instance, bool right)
{
int ventIndex = EvilPlayer.ventIndex;
((GrabbableObject)__instance).RequireCooldown();
if (!right)
{
EvilPlayer.ventIndex = Mathf.Clamp(EvilPlayer.ventIndex - 1, -1, EvilPlayer.positions.Count - 1);
}
if (EvilPlayer.ventIndex != ventIndex)
{
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)("Vent num is num! " + ventIndex + " And VentIndex is " + EvilPlayer.ventIndex));
RoundManager.PlayRandomClip(__instance.thisAudio, __instance.turnPageSFX, true, 1f, 0);
if (EvilPlayer.ventIndex == -1)
{
EvilPlayer.ventIndex = EvilPlayer.positions.Count - 1;
}
logger.LogInfo((object)("!___Vent___! " + ventIndex));
EvilPlayer.shouldTP = true;
}
logger.LogInfo((object)"tried to work");
UpdateRadarTexture((GrabbableObject)(object)__instance);
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GrabbableObject), "InspectItem")]
private static void PostfixInspectItem(GrabbableObject __instance)
{
ManualLogSource val = Logger.CreateLogSource("EvilPlayer_Imposter.Tormad");
val.LogInfo((object)"InspectItem method called.");
ClipboardItem val2 = (ClipboardItem)(object)((__instance is ClipboardItem) ? __instance : null);
if (val2 == null || (Object)(object)((GrabbableObject)val2).playerHeldBy == (Object)null)
{
val.LogInfo((object)"Not a ClipboardItem or playerHeldBy is null.");
return;
}
val.LogInfo((object)"Calling UpdateRadarTexture...");
UpdateRadarTexture(__instance);
}
private static void UpdateRadarTexture(GrabbableObject clipboardItem)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: 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)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
ManualLogSource val = Logger.CreateLogSource("EvilPlayer_Imposter.Tormad");
val.LogInfo((object)"UpdateRadarTexture method called.");
int num = 630;
int num2 = 630;
Texture2D val2 = new Texture2D(num, num2);
for (int i = 0; i < 900; i++)
{
for (int j = 0; j < 1260; j++)
{
val2.SetPixel(i, j, Color.black);
}
}
LayerMask val3 = LayerMask.op_Implicit(LayerMask.GetMask(new string[1] { "Player" }));
Transform playerpos = EvilPlayer.Playerpos;
float num3 = 30f;
Collider[] array = Physics.OverlapSphere(playerpos.position, num3, LayerMask.op_Implicit(val3));
val.LogInfo((object)$"Detected {array.Length} players.");
Collider[] array2 = array;
foreach (Collider val4 in array2)
{
Vector2 radarPosition = GetRadarPosition(((Component)val4).transform.position, playerpos, num, num2, num3);
val.LogInfo((object)$"Player detected at position: {((Component)val4).transform.position}, Radar position: {radarPosition}");
DrawDot(val2, radarPosition, Color.red, 10);
}
Vector2 radarPosition2 = GetRadarPosition(playerpos.position, playerpos, num, num2, num3);
DrawDot(val2, radarPosition2, Color.yellow, 10);
DrawDot(val2, new Vector2((float)(num / 2), (float)(num2 / 2)), Color.green, 10);
val2.Apply();
UpdateMaterial(val2, clipboardItem);
}
private static void DrawDot(Texture2D texture, Vector2 center, Color color, int dotSize)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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)
int num = -100;
for (int i = -dotSize; i <= dotSize; i++)
{
for (int j = -dotSize; j <= dotSize; j++)
{
int num2 = (int)center.x + i + num;
int num3 = (int)center.y + j;
if (num2 >= 0 && num2 < ((Texture)texture).width && num3 >= 0 && num3 < ((Texture)texture).height)
{
texture.SetPixel(num2, num3, color);
}
}
}
}
private static void UpdateMaterial(Texture2D newTexture, GrabbableObject grabbableObject)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Expected O, but got Unknown
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
ManualLogSource val = Logger.CreateLogSource("EvilPlayer_Imposter.Tormad");
val.LogInfo((object)"UpdateMaterial method called.");
Transform val2 = ((Component)grabbableObject).transform.Find("Plane");
if ((Object)(object)val2 == (Object)null)
{
val.LogWarning((object)"Child 'Plane' not found in GrabbableObject.");
return;
}
SkinnedMeshRenderer component = ((Component)val2).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component == (Object)null)
{
val.LogWarning((object)"SkinnedMeshRenderer not found on 'Plane' child.");
return;
}
Material val3 = new Material(Shader.Find("HDRP/Lit"));
val3.mainTexture = (Texture)(object)newTexture;
Color val4 = default(Color);
((Color)(ref val4))..ctor(2f, 2f, 2f);
val3.EnableKeyword("_EMISSION");
val3.SetColor("_EmissionColor", val4);
if (val3.HasProperty("_EmissionIntensity"))
{
val3.SetFloat("_EmissionIntensity", 2f);
}
((Renderer)component).material = val3;
val.LogInfo((object)"Material with emission updated successfully.");
}
private static Vector2 GetRadarPosition(Vector3 worldPos, Transform radarTransform, int radarWidth, int radarHeight, float detectionRadius)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = radarTransform.InverseTransformPoint(worldPos);
float num = (float)radarWidth / (2f * detectionRadius);
float num2 = (float)radarHeight / (2f * detectionRadius);
float num3 = val.x * num + (float)(radarWidth / 2);
float num4 = val.z * num2 + (float)(radarHeight / 2);
num3 = Mathf.Clamp(num3, 0f, (float)radarWidth);
num4 = Mathf.Clamp(num4, 0f, (float)radarHeight);
Debug.Log((object)$"Radar Pos: {num3}, {num4} for World Pos: {worldPos}");
return new Vector2(num3, num4);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GrabbableObject), "ItemActivate")]
private static void PostfixItemActivate(GrabbableObject __instance, bool used, bool buttonDown)
{
ClipboardItem val = (ClipboardItem)(object)((__instance is ClipboardItem) ? __instance : null);
if (val != null && !((Object)(object)((GrabbableObject)val).playerHeldBy == (Object)null) && buttonDown)
{
PerformInstantHit(((GrabbableObject)val).playerHeldBy);
TryUnlockDoor(((GrabbableObject)val).playerHeldBy);
if (EvilPlayer.DoorsLocked >= EvilPlayer.doorLockMax)
{
TryLockDoor(((GrabbableObject)val).playerHeldBy);
}
}
}
private static void PerformInstantHit(PlayerControllerB playerHeldBy)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
if (Time.realtimeSinceStartup - EvilPlayer.lastHitTime < EvilPlayer.hitCooldown)
{
return;
}
logger.LogInfo((object)"!_hit ");
RaycastHit[] source = Physics.SphereCastAll(((Component)playerHeldBy.gameplayCamera).transform.position, 0.75f, ((Component)playerHeldBy.gameplayCamera).transform.forward, EvilPlayer.hitDistance, attackMask, (QueryTriggerInteraction)2);
IHittable val = default(IHittable);
foreach (RaycastHit item in source.OrderBy((RaycastHit h) => ((RaycastHit)(ref h)).distance))
{
RaycastHit current = item;
if (!((Component)((RaycastHit)(ref current)).transform).TryGetComponent<IHittable>(ref val) || (Object)(object)((RaycastHit)(ref current)).transform == (Object)(object)((Component)playerHeldBy).transform)
{
continue;
}
try
{
bool flag = val.Hit(EvilPlayer.attackHitForce, ((RaycastHit)(ref current)).point, playerHeldBy, true);
logger.LogInfo((object)(flag ? "Hit successful" : "Hit failed"));
if (flag)
{
EvilPlayer.lastHitTime = Time.realtimeSinceStartup;
}
}
catch (Exception arg)
{
logger.LogError((object)$"Exception caught when hitting object with ClipboardItem: {arg}");
}
}
}
private static void TryUnlockDoor(PlayerControllerB playerHeldBy)
{
//IL_000e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
Ray val = default(Ray);
((Ray)(ref val))..ctor(((Component)playerHeldBy.gameplayCamera).transform.position, ((Component)playerHeldBy.gameplayCamera).transform.forward);
RaycastHit val2 = default(RaycastHit);
if (Physics.Raycast(val, ref val2, 3f, 2816))
{
DoorLock component = ((Component)((RaycastHit)(ref val2)).transform).GetComponent<DoorLock>();
if ((Object)(object)component != (Object)null && component.isLocked && !component.isPickingLock)
{
component.UnlockDoorSyncWithServer();
}
}
}
private static void TryLockDoor(PlayerControllerB playerHeldBy)
{
//IL_000e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
Ray val = default(Ray);
((Ray)(ref val))..ctor(((Component)playerHeldBy.gameplayCamera).transform.position, ((Component)playerHeldBy.gameplayCamera).transform.forward);
RaycastHit val2 = default(RaycastHit);
if (!Physics.Raycast(val, ref val2, 3f, 2816))
{
return;
}
DoorLock component = ((Component)((RaycastHit)(ref val2)).transform).GetComponent<DoorLock>();
if ((Object)(object)component != (Object)null && !component.isLocked)
{
component.doorLockSFX.Stop();
component.doorLockSFX.PlayOneShot(component.unlockSFX);
if (!component.isLocked)
{
component.isLocked = true;
EvilPlayer.DoorsLocked++;
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
internal class PlayerKillPatch
{
[HarmonyPrefix]
private static bool preKillPlayer(PlayerControllerB __instance)
{
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
((Renderer)__instance.thisPlayerModelArms).enabled = false;
EvilPlayer.shouldTP = true;
if (EvilPlayer.RegenHealth)
{
__instance.health = EvilPlayer.health;
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "OnDestroy")]
internal class OnDestroyPatch
{
[HarmonyPrefix]
private static void preOnDestroy(PlayerControllerB __instance)
{
EvilPlayer.evilPlayerId = 696969uL;
}
}
[HarmonyPatch(typeof(DoorLock), "Update")]
internal class DoorLockPatch
{
[HarmonyPrefix]
private static bool preUpdate(DoorLock __instance)
{
InteractTrigger val = AccessTools.FieldRefAccess<DoorLock, InteractTrigger>(__instance, "doorTrigger");
int num = AccessTools.FieldRefAccess<DoorLock, int>(__instance, "playersPickingDoor");
float num2 = AccessTools.FieldRefAccess<DoorLock, float>(__instance, "playerPickingLockProgress");
if (GameNetworkManager.Instance.localPlayerController.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
if (EvilPlayer.canUnlockDoors && __instance.isLocked)
{
if (StartOfRound.Instance.localPlayerUsingController)
{
val.disabledHoverTip = "Use key: [R-trigger]";
}
else
{
val.disabledHoverTip = "Unlock: [ LMB ]";
}
}
if (EvilPlayer.DoorsLocked >= EvilPlayer.doorLockMax && !__instance.isLocked)
{
if (StartOfRound.Instance.localPlayerUsingController)
{
val.disabledHoverTip = "Use key: [R-trigger]";
}
else
{
val.disabledHoverTip = "Lock Door: [ LMB ] only done once per moon";
}
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
internal class PlayerJumpPatch
{
[HarmonyPrefix]
private static bool preJump_performed(PlayerControllerB __instance)
{
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
string name = ((Object)((Component)__instance).gameObject).name;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)("GameObject Name: " + name));
if (__instance.playerClientId != EvilPlayer.evilPlayerId || !EvilPlayer.canFly)
{
return true;
}
if (!__instance.quickMenuManager.isMenuOpen && __instance.isPlayerControlled && !__instance.isTypingChat)
{
FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerControllerB), "isJumping");
fieldInfo.SetValue(__instance, true);
FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerControllerB), "jumpCoroutine");
Coroutine val = (Coroutine)fieldInfo2.GetValue(__instance);
if (val != null)
{
((MonoBehaviour)__instance).StopCoroutine(val);
}
MethodInfo methodInfo = AccessTools.Method(typeof(PlayerControllerB), "PlayerJump", (Type[])null, (Type[])null);
val = ((MonoBehaviour)__instance).StartCoroutine((IEnumerator)methodInfo.Invoke(__instance, null));
fieldInfo2.SetValue(__instance, val);
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
internal class DiscardHeldObjectpPatch
{
[HarmonyPrefix]
private static bool preDiscardHeldObject(PlayerControllerB __instance)
{
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
if (EvilPlayer.shipPhase && EvilPlayer.canDrop)
{
EvilPlayer.evilPlayerId = 696969uL;
return true;
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "ScrollMouse_performed")]
internal class ScrollMouse_performedPatch
{
[HarmonyPrefix]
private static bool preScrollMouse_performed(PlayerControllerB __instance)
{
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
internal class BeginGrabObjectPatch
{
[HarmonyPrefix]
private static bool preBeginGrabObject(PlayerControllerB __instance)
{
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
internal class SwitchToItemSlotPatch
{
[HarmonyPrefix]
private static bool preSwitchToItemSlot(PlayerControllerB __instance)
{
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
return true;
}
__instance.twoHanded = true;
return false;
}
}
[HarmonyPatch(typeof(EnemyVent), "Update")]
internal class EnemyVentPatch
{
[HarmonyPostfix]
private static void postUpdate(EnemyVent __instance)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: 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_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
Vector3 newPos = __instance.floorNode.position;
newPos.y += 1f;
if (!EvilPlayer.positions.Any((Vector3 pos) => pos == newPos))
{
EvilPlayer.positions.Add(newPos);
EvilPlayer.ventIndex = EvilPlayer.positions.Count / 2;
EvilPlayer.yRot.Add(__instance.floorNode.eulerAngles.y);
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"!_Added vent!");
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)newPos);
EvilPlayer.shouldTP = true;
}
}
}
[HarmonyPatch(typeof(RoundManager), "Update")]
internal class LandingCheckerPatch
{
[HarmonyPrefix]
private static void preUpdate(RoundManager __instance)
{
EvilPlayer.hasLanded = __instance.dungeonCompletedGenerating;
if (__instance.currentLevel.PlanetName != EvilPlayer.currentMoon)
{
EvilPlayer.changedSkin = false;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)("!_____" + __instance.currentLevel.PlanetName));
EvilPlayer.currentMoon = __instance.currentLevel.PlanetName;
}
}
}
[HarmonyPatch(typeof(RoundManager), "SpawnEnemyFromVent")]
internal class EnemySpawnPatch
{
[HarmonyPrefix]
private static bool preSpawnEnemyFromVent()
{
if (EvilPlayer.maxEnemy <= EvilPlayer.EnemyCount)
{
return false;
}
EvilPlayer.EnemyCount++;
return true;
}
}
[HarmonyPatch(typeof(TimeOfDay), "OnDayChanged")]
public class DayCaller
{
[HarmonyPostfix]
private static void PostfixLoadShipGrabbableItems()
{
EvilPlayer.shipPhase = true;
EvilPlayer.hasLanded = false;
Logger.CreateLogSource("Market.Tormad").LogInfo((object)"! NEW DAY BABY");
EvilPlayer.EnemyCount = 0;
EvilPlayer.changedSkin = false;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"tried to clear list");
EvilPlayer.positions.Clear();
EvilPlayer.yRot.Clear();
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
internal class PlayerControllerPatch
{
[HarmonyPrefix]
private static void PrefixUpdate(PlayerControllerB __instance)
{
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Expected O, but got Unknown
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
//IL_0435: Unknown result type (might be due to invalid IL or missing references)
//IL_054e: Unknown result type (might be due to invalid IL or missing references)
//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0503: Unknown result type (might be due to invalid IL or missing references)
//IL_0508: Unknown result type (might be due to invalid IL or missing references)
//IL_050b: Unknown result type (might be due to invalid IL or missing references)
//IL_057d: Unknown result type (might be due to invalid IL or missing references)
//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
//IL_060b: Unknown result type (might be due to invalid IL or missing references)
//IL_0632: Unknown result type (might be due to invalid IL or missing references)
if (__instance.playerClientId != EvilPlayer.evilPlayerId)
{
if (__instance.carryWeight == EvilPlayer.carryWeight)
{
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"!___Dropped___!");
UnlockableSuit.SwitchSuitForPlayer(__instance, 0, true);
__instance.movementSpeed = 4.6f;
__instance.sprintTime = 5f;
__instance.jumpForce = 13f;
__instance.hinderedMultiplier = 1f;
__instance.velocityMovingAverageLength = 20;
__instance.insanitySpeedMultiplier = 1f;
__instance.carryWeight = 1f;
__instance.grabDistance = 3f;
((Behaviour)__instance.nightVision).enabled = false;
__instance.twoHanded = false;
__instance.isMovementHindered = 0;
__instance.sprintMeter = 1f;
}
return;
}
if (__instance.playersManager.livingPlayers == 1 && __instance.playerClientId == EvilPlayer.evilPlayerId && __instance.isInsideFactory && !EvilPlayer.ShipLeaving)
{
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"ship leaving due to 1 living player");
__instance.playersManager.allPlayersDead = true;
__instance.playersManager.ShipLeaveAutomatically(false);
EvilPlayer.ShipLeaving = true;
}
if (!EvilPlayer.changedSkin)
{
Material val = new Material(Shader.Find("HDRP/Lit"));
val.SetFloat("_Smoothness", 1f);
val.SetFloat("_Metallic", 1f);
val.SetFloat("_RefractionModel", 1f);
val.SetFloat("_IOR", 1.5f);
val.SetFloat("_MaterialType", 1f);
val.SetColor("_SubsurfaceColor", Color.red);
val.SetFloat("_SurfaceType", 1f);
val.SetColor("_BaseColor", new Color(0f, 0f, 0f, EvilPlayer.transparency));
val.EnableKeyword("_RIMLIGHT");
val.SetFloat("_RimLightIntensity", 0.2f);
((Renderer)__instance.thisPlayerModel).material = val;
((Renderer)__instance.thisPlayerModelLOD1).material = val;
((Renderer)__instance.thisPlayerModelLOD2).material = val;
((Renderer)__instance.thisPlayerModelArms).material = val;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"!___Updated Material___!");
EvilPlayer.changedSkin = true;
}
if (__instance.movementSpeed != EvilPlayer.movSpeed && !__instance.isSprinting)
{
__instance.movementSpeed = EvilPlayer.movSpeed;
}
if (__instance.movementSpeed != EvilPlayer.sprintSpeed && __instance.isSprinting)
{
__instance.movementSpeed = EvilPlayer.sprintSpeed;
}
if (!__instance.isInsideFactory && !EvilPlayer.shipPhase)
{
EvilPlayer.changedSkin = false;
EvilPlayer.shipPhase = true;
}
if (__instance.isInsideFactory && EvilPlayer.shipPhase)
{
EvilPlayer.shipPhase = false;
}
if (EvilPlayer.shipPhase == __instance.isInsideFactory)
{
EvilPlayer.evilPlayerId = 696969uL;
}
if (__instance.grabDistance != 0f && EvilPlayer.shipPhase && !EvilPlayer.canInteractInShip)
{
__instance.grabDistance = 0f;
}
if (EvilPlayer.shipPhase)
{
EvilPlayer.ShipLeaving = false;
}
else if (__instance.grabDistance != 2f && !EvilPlayer.shipPhase && EvilPlayer.canOpenDoors)
{
__instance.grabDistance = 2f;
}
if (__instance.isInHangarShipRoom && !EvilPlayer.shouldTP && EvilPlayer.hasLanded)
{
EvilPlayer.shouldTP = true;
}
if (!((Behaviour)__instance.nightVision).enabled && EvilPlayer.nightVision)
{
((Behaviour)__instance.nightVision).enabled = true;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"!___night vision___!");
}
if (Time.realtimeSinceStartup > EvilPlayer.startTime1 + 20f)
{
Transform val2 = (EvilPlayer.Playerpos = __instance.cameraContainerTransform);
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)val2.eulerAngles.y);
EvilPlayer.startTime1 = Time.realtimeSinceStartup;
}
if (EvilPlayer.shouldTP && Time.realtimeSinceStartup > EvilPlayer.startTime + 0.2f)
{
EvilPlayer.startTime = Time.realtimeSinceStartup;
Transform thisPlayerBody = __instance.thisPlayerBody;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)"!___TRIED TO TELEPORT___!");
thisPlayerBody.eulerAngles = new Vector3(thisPlayerBody.eulerAngles.x, EvilPlayer.yRot[EvilPlayer.ventIndex], thisPlayerBody.eulerAngles.z);
Vector3 forward = ((Component)thisPlayerBody).transform.forward;
float num = 1f;
Vector3 val3 = EvilPlayer.positions[EvilPlayer.ventIndex] + forward * num;
__instance.TeleportPlayer(val3, false, 0f, false, true);
__instance.isInHangarShipRoom = false;
__instance.isInsideFactory = true;
if (!__instance.isInHangarShipRoom && EvilPlayer.shouldTP)
{
EvilPlayer.shouldTP = false;
}
}
if (__instance.thisPlayerBody.position.y <= -300f)
{
Transform thisPlayerBody2 = __instance.thisPlayerBody;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)thisPlayerBody2.position);
Random random = new Random();
__instance.TeleportPlayer(EvilPlayer.positions[random.Next(0, EvilPlayer.positions.Count)], false, 0f, false, true);
}
if (EvilPlayer.currentMoon == "71 Gordion" && Time.realtimeSinceStartup > EvilPlayer.startTime + 0.2f)
{
EvilPlayer.startTime = Time.realtimeSinceStartup;
Transform thisPlayerBody3 = __instance.thisPlayerBody;
Logger.CreateLogSource("EvilPlayer_Imposter.Tormad").LogInfo((object)thisPlayerBody3.position);
Random random2 = new Random();
__instance.TeleportPlayer(new Vector3(0f, 6f, 0f), false, 0f, false, true);
}
}
}
}
