public static void Prefix(
MeetingHud __instance, [HarmonyArgument(0)] PlayerControl player)
{
if (AmongUsClient.Instance.AmHost)
{
foreach (var role in Role.GetRoles(RoleEnum.Mayor))
{
if (role is Mayor mayor)
{
var votesRegained = mayor.ExtraVotes.RemoveAll(x => x == player.PlayerId);
if (mayor.Player == PlayerControl.LocalPlayer)
{
mayor.VoteBank += votesRegained;
}
var writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId,
(byte)CustomRPC.AddMayorVoteBank, SendOption.Reliable, -1);
writer.Write(mayor.Player.PlayerId);
writer.Write(mayor.VoteBank);
AmongUsClient.Instance.FinishRpcImmediately(writer);
}
}
}
}
public static void Prefix(MeetingHud __instance, GameData.PlayerInfo PPIKPNJEAKJ)
{
foreach (var Role in Role.ROLES)
{
Role.MeetingBeforeCreatePlayer(__instance, PPIKPNJEAKJ);
}
}
public static void Postfix(MeetingHud __instance, ref Il2CppStructArray <byte> __result)
{
AbilityBlackmail[] blackmailAbilities = Ability.GetAllAbilities <AbilityBlackmail>();
if (blackmailAbilities.Length == 0)
{
return;
}
foreach (PlayerVoteArea playerVoteArea in __instance.playerStates)
{
if (!playerVoteArea.didVote)
{
continue;
}
int num = playerVoteArea.votedFor + 1;
if (num < 0 || num >= __result.Length)
{
continue;
}
if (blackmailAbilities.Any(blackmail => playerVoteArea.TargetPlayerId == blackmail.BlackmailedPlayer?.PlayerId))
{
__result[num] -= (byte)(MayorPatches.MeetingHudCalculateVotesPatch.extraVote == num ? 2 : 1);
}
}
}
public static Dictionary <byte, int> CalculateVotes(MeetingHud __instance)
{
var self = RegisterExtraVotes.CalculateAllVotes(__instance);
if (SwapVotes.Swap1 == null || SwapVotes.Swap2 == null)
{
return(self);
}
//
PluginSingleton <TownOfUs> .Instance.Log.LogInfo($"Swap1 playerid = {SwapVotes.Swap1.TargetPlayerId}");
var swap1 = 0;
if (self.TryGetValue(SwapVotes.Swap1.TargetPlayerId, out var value))
{
swap1 = value;
}
PluginSingleton <TownOfUs> .Instance.Log.LogInfo($"Swap1 player has votes = {swap1}");
var swap2 = 0;
PluginSingleton <TownOfUs> .Instance.Log.LogInfo($"Swap2 playerid = {SwapVotes.Swap2.TargetPlayerId}");
if (self.TryGetValue(SwapVotes.Swap2.TargetPlayerId, out var value2))
{
swap2 = value2;
}
PluginSingleton <TownOfUs> .Instance.Log.LogInfo($"Swap2 player has votes = {swap2}");
self[SwapVotes.Swap2.TargetPlayerId] = swap1;
self[SwapVotes.Swap1.TargetPlayerId] = swap2;
return(self);
}
public static void Postfix(MeetingHud __instance)
{
foreach (var Role in Role.ROLES)
{
Role.MeetingProceed(__instance);
}
}
public static void Postfix(MeetingHud __instance)
{
foreach (var role in Role.GetRoles(RoleEnum.Assassin))
{
var assassin = (Assassin)role;
assassin.Guesses.Clear();
assassin.Buttons.Clear();
assassin.GuessedThisMeeting = false;
}
if (PlayerControl.LocalPlayer.Data.IsDead)
{
return;
}
if (!PlayerControl.LocalPlayer.Is(RoleEnum.Assassin))
{
return;
}
var assassinRole = Role.GetRole <Assassin>(PlayerControl.LocalPlayer);
if (assassinRole.RemainingKills <= 0)
{
return;
}
foreach (var voteArea in __instance.playerStates)
{
GenButton(assassinRole, voteArea);
}
}
public static void Postfix(MeetingHud __instance)
{
foreach (var pstate in __instance.playerStates)
{
if (pstate.TargetPlayerId == PlayerControl.LocalPlayer.PlayerId)
{
if (RoleInfo.IsRole(PlayerControl.LocalPlayer, Roles.Jester))
{
pstate.NameText.Color = RoleInfo.JesterColor;
}
else if (RoleInfo.IsRole(PlayerControl.LocalPlayer, Roles.Snitch))
{
pstate.NameText.Color = RoleInfo.SnitchColor;
}
else if (RoleInfo.IsRole(PlayerControl.LocalPlayer, Roles.Mechanic))
{
pstate.NameText.Color = RoleInfo.MechanicColor;
}
else if (RoleInfo.IsRole(PlayerControl.LocalPlayer, Roles.Witness))
{
pstate.NameText.Color = RoleInfo.WitnessColor;
}
else if (RoleInfo.IsRole(PlayerControl.LocalPlayer, Roles.Sheriff))
{
pstate.NameText.Color = RoleInfo.SheriffColor;
}
}
}
}
public static void Postfix(MeetingHud __instance)
{
var localPlayer = PlayerControl.LocalPlayer;
var _role = Role.GetRole(localPlayer);
if (_role?.RoleType != RoleEnum.Arsonist)
{
return;
}
var role = (Arsonist)_role;
foreach (var state in __instance.playerStates)
{
var targetId = state.TargetPlayerId;
var playerData = Utils.PlayerById(targetId)?.Data;
if (playerData == null || playerData.Disconnected)
{
role.DousedPlayers.Remove(targetId);
continue;
}
if (role.DousedPlayers.Contains(targetId))
{
state.NameText.color = Color.black;
}
}
}
private static void UpdateMeeting(MeetingHud __instance)
{
Carnivore carnivore = Carnivore.Get(PlayerControl.LocalPlayer);
foreach (PlayerVoteArea voteArea in __instance.playerStates)
{
if (!carnivore.HasEaten(voteArea.TargetPlayerId))
{
continue;
}
PlayerControl player = Utils.PlayerById(voteArea.TargetPlayerId);
Role role = Role.GetRole(player);
voteArea.NameText.color = role.Color;
if (CamouflageUnCamouflage.IsCamoed && CustomGameOptions.MeetingColourblind)
{
// TODO: Do we need this?
// voteArea.NameText.text = player.name;
}
else
{
voteArea.NameText.text = player.name + $" ({role.Name})";
}
}
}
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(MeetingHud __instance)
{
Assassin.AssassinState.Guesses.Clear();
Assassin.AssassinState.Buttons.Clear();
if (
PlayerControl.LocalPlayer.Data.IsDead ||
!PlayerControl.LocalPlayer.Is(Faction.Impostors)
)
{
return;
}
Assassin assassin = Assassin.AssassinState;
if (assassin.RemainingKills <= 0)
{
return;
}
foreach (var voteArea in __instance.playerStates)
{
IMeetingGuesser.GenButton(
assassin,
voteArea,
playerControl => !IsExempt(playerControl),
(playerControl, role) =>
{
IMeetingGuesser.KillFromMeetingGuess(assassin, playerControl, role);
assassin.RemainingKills--;
});
}
}
[HarmonyPatch("CCEPEINGBCN")] //CalculateVotes
public static void Postfix2(MeetingHud __instance, ref Il2CppStructArray <byte> __result)
{
if (Utils.Swapper == null)
{
return;
}
if (SwapVotes.Swap1 == null || SwapVotes.Swap2 == null)
{
return;
}
var array = new byte[PlayerControl.AllPlayerControls.Count + 1];
for (var i = 0; i < array.Length; i++)
{
if (i == SwapVotes.Swap1.TargetPlayerId + 1)
{
array[SwapVotes.Swap2.TargetPlayerId + 1] = __result[i];
}
else if (i == SwapVotes.Swap2.TargetPlayerId + 1)
{
array[SwapVotes.Swap1.TargetPlayerId + 1] = __result[i];
}
else
{
array[i] = __result[i];
}
}
__result = array;
}
static void addSwapperSwapButtons(MeetingHud __instance)
{
if (Swapper.swapper == null || PlayerControl.LocalPlayer != Swapper.swapper || Swapper.swapper.IDOFAMCIJKE.FGNJJFABIHJ)
{
return;
}
selections = new bool[__instance.DHCOPOOJCLN.Length];
renderers = new SpriteRenderer[__instance.DHCOPOOJCLN.Length];
for (int i = 0; i < __instance.DHCOPOOJCLN.Length; i++)
{
PlayerVoteArea playerVoteArea = __instance.DHCOPOOJCLN[i];
GameObject template = playerVoteArea.Buttons.transform.Find("CancelButton").gameObject;
GameObject checkbox = UnityEngine.Object.Instantiate(template);
checkbox.transform.SetParent(playerVoteArea.transform);
checkbox.transform.position = template.transform.position;
checkbox.transform.localPosition = new Vector3(0f, 0.03f, template.transform.localPosition.z);
SpriteRenderer renderer = checkbox.GetComponent <SpriteRenderer>();
renderer.sprite = Swapper.getCheckSprite();
renderer.color = Color.red;
PassiveButton button = checkbox.GetComponent <PassiveButton>();
button.OnClick.RemoveAllListeners();
int copiedIndex = i;
button.OnClick.AddListener((UnityEngine.Events.UnityAction)(() => onClick(copiedIndex, __instance)));
selections[i] = false;
renderers[i] = renderer;
}
}
private static void Vote(MeetingHud __instance, PlayerVoteArea area2, int num,
Component origin, bool isMayor = false)
{
////System.Console.WriteLine(PlayerControl.GameOptions.AnonymousVotes);
var playerById = GameData.Instance.GetPlayerById((byte)area2.TargetPlayerId);
var renderer =
UnityEngine.Object.Instantiate(__instance.PlayerVotePrefab);
if (PlayerControl.GameOptions.AnonymousVotes || CustomGameOptions.MayorAnonymous && isMayor
) //Should be AnonymousVotes but weird
{
//System.Console.WriteLine("ANONS");
PlayerControl.SetPlayerMaterialColors(Palette.DisabledGrey, renderer);
}
else
{
//System.Console.WriteLine("NONANONS");
PlayerControl.SetPlayerMaterialColors(playerById.ColorId, renderer);
}
var transform = renderer.transform;
transform.SetParent(origin.transform);
transform.localPosition = __instance.CounterOrigin +
new Vector3(__instance.CounterOffsets.x * num,
0f, 0f);
transform.localScale = Vector3.zero;
__instance.StartCoroutine(Effects.Bloop(num * 0.5f, transform, 1f, 0.5f));
}
private static void UpdateMeeting(MeetingHud __instance)
{
if (PlayerControl.AllPlayerControls.Count <= 1)
{
return;
}
if (!PlayerControl.LocalPlayer.Data.IsImpostor)
{
return;
}
if (Utils.Godfather == null || Utils.Mafioso == null || Utils.Janitor == null)
{
return;
}
foreach (var player in __instance.playerStates)
{
var name = player.NameText.Text;
if (name == Utils.Godfather.name || name == Utils.Godfather.name + " (G)")
{
player.NameText.Text = Utils.Godfather.name + " (G)";
}
if (name == Utils.Mafioso.name || name == Utils.Mafioso.name + " (M)")
{
player.NameText.Text = Utils.Mafioso.name + " (M)";
}
if (name == Utils.Janitor.name || name == Utils.Janitor.name + " (J)")
{
player.NameText.Text = Utils.Janitor.name + " (J)";
}
}
}
public static void Postfix(MeetingHud __instance)
{
foreach (var role in Role.GetRoles(RoleEnum.Swapper))
{
var swapper = (Swapper)role;
swapper.ListOfActives.Clear();
swapper.Buttons.Clear();
}
if (PlayerControl.LocalPlayer.Data.IsDead)
{
return;
}
if (!PlayerControl.LocalPlayer.Is(RoleEnum.Swapper))
{
return;
}
var swapperrole = Role.GetRole <Swapper>(PlayerControl.LocalPlayer);
for (var i = 0; i < __instance.playerStates.Length; i++)
{
GenButton(swapperrole, i, __instance.playerStates[i].isDead);
}
}
static bool Prefix(MeetingHud __instance)
{
if (__instance.DHCOPOOJCLN.All((PlayerVoteArea ps) => ps.isDead || ps.didVote))
{
byte[] self = calculateVotes(__instance);
bool tie;
int maxIdx = IndexOfMax(self, (byte p) => (int)p, out tie) - 1;
GameData.OFKOJOKOOAK exiled = null;
foreach (GameData.OFKOJOKOOAK pi in GameData.Instance.AllPlayers)
{
if (pi.GMBAIPNOKLP == maxIdx)
{
exiled = pi;
break;
}
}
byte[] array = new byte[10];
for (int i = 0; i < __instance.DHCOPOOJCLN.Length; i++)
{
PlayerVoteArea playerVoteArea = __instance.DHCOPOOJCLN[i];
array[(int)playerVoteArea.HMPHKKGPLAG] = playerVoteArea.GetState();
}
// RPCVotingComplete
if (AmongUsClient.Instance.HNMILJEOEKN)
{
__instance.MJIJGEBBMAO(array, exiled, tie);
}
MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(__instance.NetId, 23, Hazel.SendOption.Reliable);
messageWriter.WriteBytesAndSize(array);
messageWriter.Write((exiled != null) ? exiled.GMBAIPNOKLP : byte.MaxValue);
messageWriter.Write(tie);
messageWriter.EndMessage();
}
return(false);
}
public static byte[] CalculateVotes(MeetingHud __instance)
{
var self = MayorMod.RegisterExtraVotes.CalculateAllVotes(__instance);
var array = new byte[Mathf.Max(PlayerControl.AllPlayerControls.Count + 1, 11)];
for (var i = 0; i < array.Length; i++)
{
if (SwapVotes.Swap1 == null || SwapVotes.Swap2 == null)
{
array[i] = self[i];
continue;
}
if (i == SwapVotes.Swap1.TargetPlayerId + 1)
{
array[SwapVotes.Swap2.TargetPlayerId + 1] = self[i];
}
else if (i == SwapVotes.Swap2.TargetPlayerId + 1)
{
array[SwapVotes.Swap1.TargetPlayerId + 1] = self[i];
}
else
{
array[i] = self[i];
}
}
return(array);
}
static void Postfix(MeetingHud __instance)
{
if (JokerSettings.Joker != null)
{
if (__instance.exiledPlayer.PlayerId == JokerSettings.Joker.PlayerId)
{
MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.JokerWin, Hazel.SendOption.None, -1);
AmongUsClient.Instance.FinishRpcImmediately(writer);
localPlayers.Clear();
foreach (PlayerControl player in PlayerControl.AllPlayerControls)
{
if (player != JokerSettings.Joker)
{
player.RemoveInfected();
player.MurderPlayer(player);
player.Data.IsDead = true;
player.Data.IsImpostor = false;
}
else
{
localPlayers.Add(player);
player.Revive();
player.Data.IsDead = false;
player.Data.IsImpostor = true;
}
}
}
}
}
[HarmonyPatch("CCEPEINGBCN")] //CalculateVotes
public static bool Prefix2(MeetingHud __instance, ref Il2CppStructArray <byte> __result)
{
if (Utils.Mayor == null)
{
return(true);
}
var array = new byte[PlayerControl.AllPlayerControls.Count + 1];
foreach (var player in __instance.playerStates)
{
if (!player.didVote)
{
continue;
}
var num = (int)(player.votedFor + 1);
if (num < 0 || num >= array.Length)
{
continue;
}
array[num] += 1;
}
foreach (var number in AllowExtraVotes.ExtraVotes)
{
array[number] += 1;
}
__result = array;
return(false);
}
public static bool Prefix(MeetingHud __instance, [HarmonyArgument(0)] byte srcPlayerId,
[HarmonyArgument(1)] sbyte suspectPlayerId)
{
if (Utils.Mayor == null || srcPlayerId != Utils.Mayor.PlayerId)
{
return(true);
}
var num = AreaIndexOf(__instance, (sbyte)srcPlayerId);
var area = __instance.playerStates[num];
if (area.isDead)
{
return(false);
}
if (PlayerControl.LocalPlayer.PlayerId == srcPlayerId || AmongUsClient.Instance.GameMode != GameModes.LocalGame)
{
SoundManager.Instance.PlaySound(__instance.VoteLockinSound, false, 1f);
}
var isFirstVote = SetVote(area, suspectPlayerId);
__instance.Cast <InnerNetObject>().Method_8(1U << num);
__instance.CheckForEndVoting();
if (isFirstVote)
{
PlayerControl.LocalPlayer.RpcSendChatNote(srcPlayerId, ChatNoteTypes.DidVote);
}
return(false);
}
public static void Postfix(MeetingHud __instance, ref Il2CppStructArray <byte> __result)
{
if (!TryGetSpecialRole(out Mayor mayor) || !mayor.hasRevealed)
{
return;
}
foreach (PlayerVoteArea playerVoteArea in __instance.playerStates)
{
if (!playerVoteArea.didVote)
{
continue;
}
int num = playerVoteArea.votedFor + 1;
if (num < 0 || num >= __result.Length)
{
continue;
}
if (playerVoteArea.TargetPlayerId != mayor.Owner.PlayerId)
{
continue;
}
extraVote = num;
__result[num] += 1;
return;
}
}
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(MeetingHud __instance, [HarmonyArgument(0)] MessageReader reader, [HarmonyArgument(1)] bool initialState)
{
// Add swapper buttons
if (initialState)
{
populateButtonsPostfix(__instance);
}
}
static void Postfix(MeetingHud __instance, MessageReader DOOILGKLBBF, bool IHJEKEOFMGJ)
{
// Add swapper buttons
if (IHJEKEOFMGJ)
{
addSwapperSwapButtons(__instance);
}
}
static void Postfix(MeetingHud __instance)
{
// Deactivate skip Button if skipping on emergency meetings is disabled
if (target == null && blockSkippingInEmergencyMeetings)
{
__instance.SkipVoteButton.gameObject.SetActive(false);
}
}
public static void Postfix(MeetingHud __instance)
{
if (!PlayerControl.LocalPlayer.isMayor())
{
return;
}
__instance.TimerText.Text = "Can Vote: " + AllowExtraVotes.VoteBank + " time(s) | " + __instance.TimerText.Text;
}
public override void MeetingProceed(MeetingHud Meeting)
{
if (Player != null && Meeting.exiledPlayer != null &&
Meeting.exiledPlayer.PlayerId == Player.PlayerId)
{
SingleVictory();
}
}
public static void Postfix(MeetingHud __instance)
{
if (Sheriff.instance == null)
{
return;
}
Sheriff.instance.killTimer = CustomGameOptions.SheriffKillCD;
}
static void Postfix(MeetingHud __instance, MessageReader HFPCBBHJIPJ, bool CHDIOBMNLGH)
{
// Add swapper buttons
if (CHDIOBMNLGH)
{
addSwapperSwapButtons(__instance);
}
}
