public static bool Prefix(Vent __instance,
[HarmonyArgument(0)] GameData.PlayerInfo playerInfo,
[HarmonyArgument(1)] ref bool canUse,
[HarmonyArgument(2)] ref bool couldUse,
ref float __result)
{
__result = float.MaxValue;
canUse = couldUse = false;
var player = playerInfo.Object;
if (player.inVent)
{
__result = Vector2.Distance(player.Collider.bounds.center, __instance.transform.position);
canUse = couldUse = true;
return(false);
}
if (player.Is(RoleEnum.Morphling) ||
player.Is(RoleEnum.Swooper) ||
(player.Is(RoleEnum.Undertaker) && Role.GetRole <Undertaker>(player).CurrentlyDragging != null))
{
return(false);
}
if (player.Is(RoleEnum.Engineer))
{
playerInfo.IsImpostor = true;
}
return(true);
}
static PlayerControl setAnyRoleTarget()
{
PlayerControl result = null;
float num = GameOptionsData.KillDistances[Mathf.Clamp(PlayerControl.GameOptions.KillDistance, 0, 2)];
if (!ShipStatus.Instance)
{
return(result);
}
Vector2 truePosition = PlayerControl.LocalPlayer.GetTruePosition();
Il2CppSystem.Collections.Generic.List <GameData.PlayerInfo> allPlayers = GameData.Instance.AllPlayers;
for (int i = 0; i < allPlayers.Count; i++)
{
GameData.PlayerInfo playerInfo = allPlayers[i];
if (!playerInfo.Disconnected && playerInfo.PlayerId != PlayerControl.LocalPlayer.PlayerId && !playerInfo.IsDead)
{
PlayerControl @object = playerInfo.Object;
if (@object && [email protected])
{
Vector2 vector = @object.GetTruePosition() - truePosition;
float magnitude = vector.magnitude;
if (magnitude <= num && !PhysicsHelpers.AnyNonTriggersBetween(truePosition, vector.normalized, magnitude, Constants.ShipAndObjectsMask))
{
result = @object;
num = magnitude;
}
}
}
}
return(result);
}
static void Postfix(MapBehaviour __instance)
{
if (PlayerControl.LocalPlayer.isGM())
{
if (mapIcons == null || corpseIcons == null)
{
initializeIcons(__instance);
}
__instance.taskOverlay.Hide();
foreach (byte id in mapIcons.Keys)
{
GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(id);
PlayerControl.SetPlayerMaterialColors(playerById.Object.CurrentOutfit.ColorId, mapIcons[id]);
mapIcons[id].enabled = !playerById.IsDead;
}
foreach (DeadBody b in Object.FindObjectsOfType <DeadBody>())
{
byte id = b.ParentId;
GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(id);
PlayerControl.SetPlayerMaterialColors(playerById.Object.CurrentOutfit.ColorId, corpseIcons[id]);
corpseIcons[id].enabled = true;
}
}
}
static bool Prefix(Console __instance, GameData.PlayerInfo __0, out bool __1, out bool __2)
{
float num = float.MaxValue;
PlayerControl @object = __0.Object;
var flag = @object.Is(RoleEnum.Glitch) || @object.Is(RoleEnum.Jester) ||
@object.Is(RoleEnum.Shifter) || @object.Is(RoleEnum.Executioner) ||
@object.Is(RoleEnum.Arsonist);
Vector2 truePosition = @object.GetTruePosition();
Vector3 position = __instance.transform.position;
__2 = ((!__0.IsDead || (PlayerControl.GameOptions.GhostsDoTasks && !__instance.GhostsIgnored)) &&
@object.CanMove &&
(__instance.AllowImpostor || (!flag && !__0.IsImpostor)) &&
(!__instance.onlySameRoom || MethodRewrites.InRoom(__instance, truePosition)) &&
(!__instance.onlyFromBelow || truePosition.y < position.y) &&
MethodRewrites.FindTask(__instance, @object));
__1 = __2;
if (__1)
{
num = Vector2.Distance(truePosition, __instance.transform.position);
__1 &= (num <= __instance.UsableDistance);
if (__instance.checkWalls)
{
__1 &= !PhysicsHelpers.AnythingBetween(truePosition, position, Constants.ShadowMask, false);
}
}
return(false);
}
public static void Prefix(IntroCutscene __instance)
{
// Arsonist generate player icons
if (PlayerControl.LocalPlayer != null && PlayerControl.LocalPlayer == Arsonist.arsonist && HudManager.Instance != null)
{
int playerCounter = 0;
Vector3 bottomLeft = new Vector3(-HudManager.Instance.UseButton.transform.localPosition.x, HudManager.Instance.UseButton.transform.localPosition.y, HudManager.Instance.UseButton.transform.localPosition.z);
bottomLeft += new Vector3(-0.25f, -0.25f, 0);
foreach (PlayerControl player in PlayerControl.AllPlayerControls)
{
if (player != PlayerControl.LocalPlayer)
{
GameData.PlayerInfo data = player.Data;
PoolablePlayer poolablePlayer = UnityEngine.Object.Instantiate <PoolablePlayer>(__instance.PlayerPrefab, HudManager.Instance.transform);
poolablePlayer.transform.localPosition = bottomLeft + Vector3.right * playerCounter * 0.35f;
poolablePlayer.transform.localScale = Vector3.one * 0.3f;
PlayerControl.SetPlayerMaterialColors(data.ColorId, poolablePlayer.Body);
DestroyableSingleton <HatManager> .Instance.SetSkin(poolablePlayer.SkinSlot, data.SkinId);
poolablePlayer.HatSlot.SetHat(data.HatId, data.ColorId);
PlayerControl.SetPetImage(data.PetId, data.ColorId, poolablePlayer.PetSlot);
poolablePlayer.NameText.text = data.PlayerName;
poolablePlayer.SetFlipX(true);
poolablePlayer.setSemiTransparent(true);
Arsonist.dousedIcons[player.PlayerId] = poolablePlayer;
playerCounter++;
}
}
}
}
private static bool Prefix(GameData __instance)
{
__instance.TotalTasks = 0;
__instance.CompletedTasks = 0;
for (int i = 0; i < __instance.AllPlayers.Count; i++)
{
GameData.PlayerInfo playerInfo = __instance.AllPlayers[i]; // PlayerInfo
if (!playerInfo.Disconnected && playerInfo.Tasks != null && // Disconnected | // Tasks
playerInfo.Object && // Object -> PlayerControl
(PlayerControl.GameOptions.GhostsDoTasks || !playerInfo.IsDead) && // GhostsDoTasks | IsDead
!playerInfo.IsImpostor && // IsImpostor
!Helpers.hasFakeTasks(playerInfo.Object)
)
{
for (int j = 0; j < playerInfo.Tasks.Count; j++)
{
__instance.TotalTasks++;
if (playerInfo.Tasks[j].Complete) // Complete
{
__instance.CompletedTasks++;
}
}
}
}
return(false);
}
static void Postfix(VitalsMinigame __instance)
{
// Hacker show time since death
if (Hacker.hacker != null && Hacker.hacker == PlayerControl.LocalPlayer && Hacker.hackerTimer > 0)
{
for (int k = 0; k < __instance.vitals.Length; k++)
{
VitalsPanel vitalsPanel = __instance.vitals[k];
GameData.PlayerInfo player = GameData.Instance.AllPlayers[k];
// Hacker update
if (vitalsPanel.IsDead)
{
DeadPlayer deadPlayer = deadPlayers?.Where(x => x.player?.PlayerId == player?.PlayerId)?.FirstOrDefault();
if (deadPlayer != null && deadPlayer.timeOfDeath != null && k < hackerTexts.Count && hackerTexts[k] != null)
{
float timeSinceDeath = ((float)(DateTime.UtcNow - deadPlayer.timeOfDeath).TotalMilliseconds);
hackerTexts[k].gameObject.SetActive(true);
hackerTexts[k].text = Math.Round(timeSinceDeath / 1000) + "s";
}
}
}
}
else
{
foreach (TMPro.TextMeshPro text in hackerTexts)
{
if (text != null && text.gameObject != null)
{
text.gameObject.SetActive(false);
}
}
}
}
public static PlayerControl FindClosestPlayer(this PlayerControl player)
{
PlayerControl result = null;
float num = GameOptionsData.KillDistances[Mathf.Clamp(PlayerControl.GameOptions.KillDistance, 0, 2)];
if (!ShipStatus.Instance)
{
return(null);
}
Vector2 truePosition = player.GetTruePosition();
List <GameData.PlayerInfo> allPlayers = GameData.Instance.AllPlayers.ToArray().ToList();
for (int i = 0; i < allPlayers.Count; i++)
{
GameData.PlayerInfo playerInfo = allPlayers[i];
if (!playerInfo.Disconnected && playerInfo.PlayerId != player.PlayerId && !playerInfo.IsDead)
{
PlayerControl @object = playerInfo.Object;
if (@object)
{
Vector2 vector = @object.GetTruePosition() - truePosition;
float magnitude = vector.magnitude;
if (magnitude <= num && !PhysicsHelpers.AnyNonTriggersBetween(truePosition, vector.normalized, magnitude, Constants.ShipAndObjectsMask))
{
result = @object;
num = magnitude;
}
}
}
}
return(result);
}
public static void BeginImpostor(IntroCutscene introCutscene)
{
introCutscene.ImpostorText.gameObject.SetActive(false);
introCutscene.Title.Text =
DestroyableSingleton <TranslationController> .Instance.GetString(StringNames.Impostor,
(Il2CppReferenceArray <Object>) Array.Empty <object>());
introCutscene.Title.Color = Palette.ImpostorRed;
GameData.PlayerInfo data = PlayerControl.LocalPlayer.Data;
if (data != null)
{
int num = -1;
int num2 = 1 / 2;
float num3 = 1f - (float)num2 * 0.075f;
float num4 = 1f - (float)num2 * 0.035f;
float num5 = -8;
PoolablePlayer poolablePlayer =
UnityEngine.Object.Instantiate <PoolablePlayer>(introCutscene.PlayerPrefab, introCutscene.transform);
poolablePlayer.transform.localPosition = new Vector3((float)(num * num2) * num4,
introCutscene.BaseY + (float)num2 * 0.15f, num5 + (float)num2 * 0.01f) * 1.5f;
Vector3 vector = new Vector3(num3, num3, num3) * 1.5f;
poolablePlayer.transform.localScale = vector;
poolablePlayer.SetFlipX(false);
PlayerControl.SetPlayerMaterialColors((int)data.ColorId, poolablePlayer.Body);
//DestroyableSingleton<HatManager>.Instance.SetSkin(poolablePlayer.SkinSlot, data.SkinId);
poolablePlayer.HatSlot.SetHat(data.HatId, (int)data.ColorId);
PlayerControl.SetPetImage(data.PetId, (int)data.ColorId, poolablePlayer.PetSlot);
TextRenderer nameText = poolablePlayer.NameText;
nameText.Text = data.PlayerName;
nameText.transform.localScale = vector.Inv();
}
}
static void WrapUpPostfix(GameData.PlayerInfo exiled)
{
// Mini exile lose condition
if (exiled != null)
{
var p = Helpers.playerById(exiled.PlayerId);
if (p.hasModifier(ModifierType.Mini) && !Mini.isGrownUp(p) && !p.Data.Role.IsImpostor && !p.isNeutral())
{
Mini.triggerMiniLose = true;
}
// Jester win condition
else if (p.isRole(RoleType.Jester))
{
Jester.triggerJesterWin = true;
}
}
if (SubmergedCompatibility.isSubmerged())
{
var fullscreen = UnityEngine.GameObject.Find("FullScreen500(Clone)");
if (fullscreen)
{
fullscreen.SetActive(false);
}
}
Logger.info("-----------Task Start-----------", "Phase");
}
public static void Postfix([HarmonyArgument(0)] GameData.PlayerInfo exiled, CNNGMDOPELD __instance)
{
PlayerControl wowww = null;
foreach (PlayerControl player in PlayerControl.AllPlayerControls)
{
if (!PlayerControl.GameOptions.ConfirmImpostor)
{
continue;
}
if (player.PlayerId != exiled.PlayerId)
{
continue;
}
if (!player.isPlayerRole("Pheonix"))
{
continue;
}
wowww = player;
}
if (wowww != null)
{
__instance.EOFFAJKKDMI = exiled.PlayerName + " was Our Pheonix.";
}
}
public static void Prefix(MeetingHud __instance, GameData.PlayerInfo PPIKPNJEAKJ)
{
foreach (var Role in Role.ROLES)
{
Role.MeetingBeforeCreatePlayer(__instance, PPIKPNJEAKJ);
}
}
static void Postfix(VitalsMinigame __instance)
{
// Spy show time since death
bool showSpyInfo = Spy.spy != null && Spy.spy == PlayerControl.LocalPlayer && Spy.spyTimer > 0;
for (int k = 0; k < __instance.vitals.Length; k++)
{
VitalsPanel vitalsPanel = __instance.vitals[k];
GameData.PlayerInfo playerInfo = GameData.Instance.AllPlayers[k];
if (vitalsPanel.IsDead)
{
DeadPlayer deadPlayer = deadPlayers?.Where(x => x.player?.PlayerId == playerInfo?.PlayerId)?.FirstOrDefault();
if (deadPlayer != null && deadPlayer.timeOfDeath != null)
{
float timeSinceDeath = ((float)(DateTime.UtcNow - deadPlayer.timeOfDeath).TotalMilliseconds);
if (showSpyInfo)
{
vitalsPanel.Text.Text = Math.Round(timeSinceDeath / 1000) + "s";
}
else
{
vitalsPanel.Text.Text = DestroyableSingleton <TranslationController> .Instance.GetString(Palette.ShortColorNames[(int)playerInfo.ColorId], new UnhollowerBaseLib.Il2CppReferenceArray <Il2CppSystem.Object>(0));
}
}
}
}
}
public static void Postfix(Vent __instance, [HarmonyArgument(0)] GameData.PlayerInfo playerInfo)
{
if (playerInfo.Object.Is(RoleEnum.Engineer))
{
playerInfo.IsImpostor = false;
}
}
static bool Prefix(MeetingHud __instance, [HarmonyArgument(0)] byte callId, [HarmonyArgument(1)] MessageReader reader)
{
switch (callId)
{
case 22:
__instance.Close();
break;
case 23: {
byte[] states = reader.ReadBytesAndSize();
byte[] votes = reader.ReadBytesAndSize();
GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(reader.ReadByte());
bool tie = reader.ReadBoolean();
VotingComplete(__instance, states, votes, playerById, tie);
break;
}
case 24: {
byte srcPlayerId = reader.ReadByte();
sbyte suspectPlayerId = reader.ReadSByte();
__instance.CastVote(srcPlayerId, suspectPlayerId);
break;
}
case 25:
__instance.ClearVote();
break;
}
return(false);
}
static void Postfix(PlayerControl __instance, GameData.PlayerInfo __0)
{
if (!__instance.HasPlayerRole(Role.Detective) || !__instance.AmOwner)
{
return;
}
var playerData = PlayerControl.LocalPlayer.GetPlayerData();
DeadPlayer corpse = playerData.DeadPlayers.Where(x => x.Player.PlayerId == __0.PlayerId).FirstOrDefault();
if (corpse != null)
{
var deathTime = (float)(DateTime.UtcNow - corpse.Timestamp).TotalMilliseconds / 1000;
if (deathTime < PlayerDataManager.Instance.Config.DetectiveDeathReportThreshold)
{
foreach (var reportMsg in corpse.DeathDetails)
{
DestroyableSingleton <HudManager> .Instance.Chat.AddChat(PlayerControl.LocalPlayer, reportMsg);
}
}
else
{
DestroyableSingleton <HudManager> .Instance.Chat.AddChat(PlayerControl.LocalPlayer, Properties.Resources.CorpseTooOld);
}
DestroyableSingleton <HudManager> .Instance.Chat.AddChat(PlayerControl.LocalPlayer, string.Format(Properties.Resources.CorpseAge, Math.Round(deathTime)));
}
}
public static bool Prefix(MeetingHud __instance)
{
if (!__instance.playerStates.All(ps => ps.isDead || ps.didVote))
{
return(false);
}
byte[] self = calculateVotes(__instance.playerStates);
int maxIdx = indexOfMax(self, out bool tie) - 1;
GameData.PlayerInfo exiled = GameData.Instance.GetPlayerById((byte)maxIdx);
byte[] states = __instance.playerStates.Select(s => s.GetState()).ToArray();
byte[] votes = __instance.playerStates.Select(s => (byte)s.votedFor).ToArray();
if (AmongUsClient.Instance.AmHost)
{
MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(__instance.NetId, 23, SendOption.Reliable);
messageWriter.WriteBytesAndSize(states);
messageWriter.WriteBytesAndSize(votes); //Added because of the state's 4 bit vote id limit
messageWriter.Write(exiled?.PlayerId ?? byte.MaxValue);
messageWriter.Write(tie);
messageWriter.EndMessage();
}
MeetingHudHandleRpcPatch.VotingComplete(__instance, states, votes, exiled, tie);
return(false);
}
public static void Postfix(ref float __result, GameData.PlayerInfo IIEKJBMPELC)
{
if (IsCultistUsed && IsCultist(IIEKJBMPELC.PlayerId))
{
__result = __result * CultistVisionModifier;
}
}
public static void Postfix([HarmonyArgument(0)] GameData.PlayerInfo exiled, ExileController __instance)
{
foreach (PlayerControl player in PlayerControl.AllPlayerControls)
{
if (!PlayerControl.GameOptions.ConfirmImpostor)
{
continue;
}
if (player.PlayerId != exiled.PlayerId)
{
continue;
}
if (!player.isAnyRole())
{
continue;
}
foreach (RoleGenerator role in allRoles)
{
if (role.containedPlayerIds.Contains(player.PlayerId))
{
__instance.completeString = exiled.PlayerName + " " + role.EjectionText;
}
}
}
}
public static void Postfix(ExileController __instance, GameData.PlayerInfo LNMDIKCFBAK)
{
int playersLeft = PlayerControl.AllPlayerControls.ToArray().Count(pc =>
pc.Data.IsDead || pc.Data.Disconnected) + (LNMDIKCFBAK != null ? 1 : 0);
udpateBools(playersLeft);
}
static bool Prefix(GameData __instance)
{
__instance.TotalTasks = 0;
__instance.CompletedTasks = 0;
for (int i = 0; i < __instance.AllPlayers.Count; i++)
{
GameData.PlayerInfo playerInfo = __instance.AllPlayers[i];
if (!playerInfo.Disconnected && playerInfo.Tasks != null && playerInfo.Object &&
(PlayerControl.GameOptions.GhostsDoTasks || !playerInfo.IsDead) && !playerInfo.IsImpostor &&
!(
playerInfo._object.Is(RoleEnum.Jester) || playerInfo._object.Is(RoleEnum.Shifter) ||
playerInfo._object.Is(RoleEnum.Glitch) || playerInfo._object.Is(RoleEnum.Executioner) ||
playerInfo._object.Is(RoleEnum.Arsonist)
))
{
for (int j = 0; j < playerInfo.Tasks.Count; j++)
{
__instance.TotalTasks++;
if (playerInfo.Tasks[j].Complete)
{
__instance.CompletedTasks++;
}
}
}
}
return(false);
}
public static void Postfix1(ref float __result, ShipStatus __instance, [HarmonyArgument(0)] GameData.PlayerInfo PlayerData)
{
if (Lighter.lighter != null && Lighter.lighter.PlayerId == PlayerData.PlayerId)
{
__result = __instance.MaxLightRadius * Lighter.lighterVision;
}
}
public static bool Prefix(ShipStatus __instance, [HarmonyArgument(0)] GameData.PlayerInfo player,
ref float __result)
{
if (player == null || player.IsDead)
{
__result = __instance.MaxLightRadius;
return(false);
}
var switchSystem = __instance.Systems[SystemTypes.Electrical].Cast <SwitchSystem>();
if (player.IsImpostor)
{
__result = __instance.MaxLightRadius * PlayerControl.GameOptions.ImpostorLightMod;
return(false);
}
var t = switchSystem.Value / 255f;
__result = Mathf.Lerp(__instance.MinLightRadius, __instance.MaxLightRadius, t) * PlayerControl.GameOptions.CrewLightMod;
if (player.Object.isMayor())
{
__result = Mathf.Lerp(__instance.MinLightRadius, __instance.MaxLightRadius, t) *
CustomGameOptions.MayorVision;
}
if (player.Object.isEngineer())
{
__result = Mathf.Lerp(__instance.MinLightRadius, __instance.MaxLightRadius, t) *
CustomGameOptions.EngineerVision;
}
return(false);
}
public static void Postfix([HarmonyArgument(0)] GameData.PlayerInfo playerInfo, ref bool __state)
{
if (__state)
{
playerInfo.IsDead = true;
}
}
public static PlayerControl FindClosestTarget(PlayerControl currentPlayer)
{
PlayerControl playerControl1 = (PlayerControl)null;
float num = GameOptionsData.KillDistances[Mathf.Clamp(PlayerControl.GameOptions.KillDistance, 0, 2)];
if (!(bool)ShipStatus.Instance)
{
return(null);
}
Vector2 truePosition = currentPlayer.GetTruePosition();
Il2CppSystem.Collections.Generic.List <GameData.PlayerInfo> allPlayers = GameData.Instance.AllPlayers;
for (int index = 0; index < allPlayers.Count; ++index)
{
GameData.PlayerInfo playerInfo = allPlayers[index];
if (!playerInfo.Disconnected && playerInfo.PlayerId != currentPlayer.PlayerId && !playerInfo.IsDead)
{
PlayerControl playerControl2 = playerInfo.Object;
if ((bool)playerControl2)
{
Vector2 vector2 = playerControl2.GetTruePosition() - truePosition;
float magnitude = vector2.magnitude;
if (magnitude <= (double)num && !PhysicsHelpers.AnyNonTriggersBetween(truePosition, vector2.normalized, magnitude, Constants.ShipAndObjectsMask))
{
playerControl1 = playerControl2;
num = magnitude;
}
}
}
}
return(playerControl1);
}
public static bool Prefix(Vent __instance, ref float __result, [HarmonyArgument(0)] GameData.PlayerInfo pc, [HarmonyArgument(1)] out bool canUse, [HarmonyArgument(2)] out bool couldUse)
{
float num = float.MaxValue;
PlayerControl localPlayer = pc.Object;
switch (Glaucus.WhoCanVent.GetValue())
{
case 0: // Nobody
couldUse = false;
break;
case 1: // Impostors
couldUse = localPlayer.Data.IsImpostor && !localPlayer.Data.IsDead;
break;
case 2: // Everyone
couldUse = !localPlayer.Data.IsDead;
break;
default:
couldUse = false;
break;
}
canUse = couldUse;
if ((DateTime.UtcNow - PlayerVentTimeExtension.GetLastVent(pc.Object.PlayerId)).TotalMilliseconds > 1000)
{
num = Vector2.Distance(localPlayer.GetTruePosition(), __instance.transform.position);
canUse &= num <= __instance.UsableDistance;
}
__result = num;
return(false);
}
static bool Prefix(PlayerPhysics __instance)
{
ModdedPlayerClass moddedController = Main.Instance.ModdedPlayerById(__instance.myPlayer.PlayerId);
if (__instance.myPlayer != PlayerControl.LocalPlayer || moddedController?.Role?.RoleName != "Bellatrix" || ((Bellatrix)moddedController.Role).MindControlledPlayer == null)
{
return(true);
}
PlayerPhysics controlledPlayer = ((Bellatrix)moddedController.Role).MindControlledPlayer._Object.MyPhysics;
GameData.PlayerInfo data = moddedController._Object.Data;
bool flag = data != null && data.IsDead;
Vector2 vel = HudManager.Instance.joystick.Delta * __instance.TrueSpeed;
controlledPlayer.body.velocity = vel;
MessageWriter writer = AmongUsClient.Instance.StartRpc(PlayerControl.LocalPlayer.NetId, (byte)Packets.MoveControlledPlayer, Hazel.SendOption.Reliable);
writer.Write(controlledPlayer.myPlayer.PlayerId);
writer.Write(vel.x);
writer.Write(vel.y);
writer.EndMessage();
return(false);
}
public static void Postfix(ref float __result, ShipStatus __instance, [HarmonyArgument(0)] GameData.PlayerInfo PlayerData)
{
if (GlobalVariables.lthcPlayer != null && Helper.lthcPlayer(PlayerData.PlayerId))
{
__result = __instance.MaxLightRadius * PlayerControl.GameOptions.CrewLightMod * 1.3f;
}
}
public static void Prefix(ExileController __instance, [HarmonyArgument(0)] ref GameData.PlayerInfo exiled, [HarmonyArgument(1)] bool tie)
{
if (exiled != null && exiled.Object == target)
{
OnTargetExiled();
}
}
public static bool Prefix(Vent __instance, ref float __result, [HarmonyArgument(0)] GameData.PlayerInfo pc, [HarmonyArgument(1)] out bool canUse, [HarmonyArgument(2)] out bool couldUse)
{
float num = float.MaxValue;
PlayerControl localPlayer = pc.Object;
switch (UnknownImpostor.WhoCanVent.GetValue())
{
case 0: // Nobody
couldUse = false;
break;
case 1: // Impostors
couldUse = localPlayer.Data.IsImpostor && !localPlayer.Data.IsDead;
break;
case 2: // Everyone
couldUse = !localPlayer.Data.IsDead;
break;
default:
couldUse = false;
break;
}
canUse = couldUse;
num = Vector2.Distance(localPlayer.GetTruePosition(), __instance.transform.position);
canUse &= num <= __instance.UsableDistance;
__result = num;
return(false);
}
