+init

1 files changed, 734 insertions, 0 deletions

diff --git a/Client/Assembly-CSharp/MeetingHud.cs b/Client/Assembly-CSharp/MeetingHud.cs
new file mode 100644
index 0000000..dbc22cb
--- /dev/null
+++ b/Client/Assembly-CSharp/MeetingHud.cs
@@ -0,0 +1,734 @@
+using System;
+using System.Collections;
+using System.Linq;
+using Assets.CoreScripts;
+using Hazel;
+using InnerNet;
+using UnityEngine;
+
+public class MeetingHud : InnerNetObject, IDisconnectHandler
+{
+	private const float ResultsTime = 5f;
+
+	private const float Depth = -100f;
+
+	public static MeetingHud Instance;
+
+	public Transform ButtonParent;
+
+	public TextRenderer TitleText;
+
+	public Vector3 VoteOrigin = new Vector3(-3.6f, 1.75f);
+
+	public Vector3 VoteButtonOffsets = new Vector2(3.6f, -0.91f);
+
+	private Vector3 CounterOrigin = new Vector2(0.5f, -0.13f);
+
+	private Vector3 CounterOffsets = new Vector2(0.3f, 0f);
+
+	public PlayerVoteArea SkipVoteButton;
+
+	[HideInInspector]
+	private PlayerVoteArea[] playerStates;
+
+	public PlayerVoteArea PlayerButtonPrefab;
+
+	public SpriteRenderer PlayerVotePrefab;
+
+	public Sprite CrackedGlass;
+
+	public SpriteRenderer Glass;
+
+	public PassiveButton ProceedButton;
+
+	public ExileController ExileCutscenePrefab;
+
+	public AudioClip VoteSound;
+
+	public AudioClip VoteLockinSound;
+
+	public AudioClip VoteEndingSound;
+
+	private MeetingHud.VoteStates state;
+
+	public SpriteRenderer SkippedVoting;
+
+	public SpriteRenderer HostIcon;
+
+	public Sprite KillBackground;
+
+	private GameData.PlayerInfo exiledPlayer;
+
+	private bool wasTie;
+
+	public TextRenderer TimerText;
+
+	public float discussionTimer;
+
+	private byte reporterId;
+
+	private bool amDead;
+
+	private float resultsStartedAt;
+
+	private int lastSecond = 10;
+
+	public enum VoteStates
+	{
+		Discussion,
+		NotVoted,
+		Voted,
+		Results,
+		Proceeding
+	}
+
+	private enum RpcCalls
+	{
+		Close,
+		VotingComplete,
+		CastVote,
+		ClearVote
+	}
+
+	private void Awake()
+	{
+		if (!MeetingHud.Instance)
+		{
+			MeetingHud.Instance = this;
+			return;
+		}
+		if (MeetingHud.Instance != this)
+		{
+			UnityEngine.Object.Destroy(base.gameObject);
+		}
+	}
+
+	private void Start()
+	{
+		DestroyableSingleton<HudManager>.Instance.Chat.gameObject.SetActive(true);
+		DestroyableSingleton<HudManager>.Instance.Chat.SetPosition(this);
+		DestroyableSingleton<HudManager>.Instance.StopOxyFlash();
+		DestroyableSingleton<HudManager>.Instance.StopReactorFlash();
+		this.SkipVoteButton.TargetPlayerId = -1;
+		this.SkipVoteButton.Parent = this;
+		Camera.main.GetComponent<FollowerCamera>().Locked = true;
+		if (PlayerControl.LocalPlayer.Data.IsDead)
+		{
+			this.SetForegroundForDead();
+		}
+		AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);
+	}
+
+	private void SetForegroundForDead()
+	{
+		this.amDead = true;
+		this.SkipVoteButton.gameObject.SetActive(false);
+		this.Glass.sprite = this.CrackedGlass;
+		this.Glass.color = Color.white;
+	}
+
+	public void Update()
+	{
+		this.discussionTimer += Time.deltaTime;
+		this.UpdateButtons();
+		switch (this.state)
+		{
+		case MeetingHud.VoteStates.Discussion:
+		{
+			if (this.discussionTimer < (float)PlayerControl.GameOptions.DiscussionTime)
+			{
+				float f = (float)PlayerControl.GameOptions.DiscussionTime - this.discussionTimer;
+				this.TimerText.Text = string.Format("Voting Begins In: {0}s", Mathf.CeilToInt(f));
+				for (int i = 0; i < this.playerStates.Length; i++)
+				{
+					this.playerStates[i].SetDisabled();
+				}
+				this.SkipVoteButton.SetDisabled();
+				return;
+			}
+			this.state = MeetingHud.VoteStates.NotVoted;
+			bool active = PlayerControl.GameOptions.VotingTime > 0;
+			this.TimerText.gameObject.SetActive(active);
+			for (int j = 0; j < this.playerStates.Length; j++)
+			{
+				this.playerStates[j].SetEnabled();
+			}
+			this.SkipVoteButton.SetEnabled();
+			return;
+		}
+		case MeetingHud.VoteStates.NotVoted:
+		case MeetingHud.VoteStates.Voted:
+			if (PlayerControl.GameOptions.VotingTime > 0)
+			{
+				float num = this.discussionTimer - (float)PlayerControl.GameOptions.DiscussionTime;
+				float f2 = Mathf.Max(0f, (float)PlayerControl.GameOptions.VotingTime - num);
+				this.TimerText.Text = string.Format("Voting Ends In: {0}s", Mathf.CeilToInt(f2));
+				if (this.state == MeetingHud.VoteStates.NotVoted && Mathf.CeilToInt(f2) <= this.lastSecond)
+				{
+					this.lastSecond--;
+					base.StartCoroutine(Effects.PulseColor(this.TimerText, Color.red, Color.white, 0.25f));
+					SoundManager.Instance.PlaySound(this.VoteEndingSound, false, 1f).pitch = Mathf.Lerp(1.5f, 0.8f, (float)this.lastSecond / 10f);
+				}
+				if (AmongUsClient.Instance.AmHost && num >= (float)PlayerControl.GameOptions.VotingTime)
+				{
+					this.ForceSkipAll();
+					return;
+				}
+			}
+			break;
+		case MeetingHud.VoteStates.Results:
+			if (AmongUsClient.Instance.GameMode == GameModes.OnlineGame)
+			{
+				float num2 = this.discussionTimer - this.resultsStartedAt;
+				float num3 = Mathf.Max(0f, 5f - num2);
+				this.TimerText.Text = string.Format("Proceeding In: {0}s", Mathf.CeilToInt(num3));
+				if (AmongUsClient.Instance.AmHost && num3 <= 0f)
+				{
+					this.HandleProceed();
+				}
+			}
+			break;
+		default:
+			return;
+		}
+	}
+
+	public IEnumerator CoIntro(PlayerControl reporter, GameData.PlayerInfo targetPlayer)
+	{
+		if (DestroyableSingleton<HudManager>.InstanceExists)
+		{
+			DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed();
+			base.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);
+			base.transform.localPosition = new Vector3(0f, -10f, -100f);
+			DestroyableSingleton<HudManager>.Instance.SetHudActive(false);
+		}
+		OverlayKillAnimation killAnimPrefab = (targetPlayer == null) ? DestroyableSingleton<HudManager>.Instance.KillOverlay.EmergencyOverlay : DestroyableSingleton<HudManager>.Instance.KillOverlay.ReportOverlay;
+		DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowOne(killAnimPrefab, reporter, targetPlayer);
+		yield return DestroyableSingleton<HudManager>.Instance.KillOverlay.WaitForFinish();
+		Vector3 temp = new Vector3(0f, 0f, -50f);
+		for (float timer = 0f; timer < 0.25f; timer += Time.deltaTime)
+		{
+			float t = timer / 0.25f;
+			temp.y = Mathf.SmoothStep(-10f, 0f, t);
+			base.transform.localPosition = temp;
+			yield return null;
+		}
+		temp.y = 0f;
+		base.transform.localPosition = temp;
+		this.TitleText.Text = "Who Is The Impostor?";
+		if (!PlayerControl.LocalPlayer.Data.IsDead)
+		{
+			yield return DestroyableSingleton<HudManager>.Instance.ShowEmblem(false);
+		}
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			base.StartCoroutine(this.playerStates[i].CoAnimateOverlay());
+		}
+		yield break;
+	}
+
+	private IEnumerator CoStartCutscene()
+	{
+		yield return DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear, Color.black, 1f);
+		ExileController exileController = UnityEngine.Object.Instantiate<ExileController>(this.ExileCutscenePrefab);
+		exileController.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform, false);
+		exileController.transform.localPosition = new Vector3(0f, 0f, -60f);
+		exileController.Begin(this.exiledPlayer, this.wasTie);
+		this.DespawnOnDestroy = false;
+		UnityEngine.Object.Destroy(base.gameObject);
+		yield break;
+	}
+
+	public void ServerStart(byte reporter)
+	{
+		this.reporterId = reporter;
+		this.PopulateButtons(reporter);
+	}
+
+	public void Close()
+	{
+		GameData.PlayerInfo data = PlayerControl.LocalPlayer.Data;
+		DestroyableSingleton<HudManager>.Instance.Chat.SetPosition(null);
+		DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(data.IsDead);
+		base.StartCoroutine(this.CoStartCutscene());
+	}
+
+	private void VotingComplete(byte[] states, GameData.PlayerInfo exiled, bool tie)
+	{
+		if (this.state == MeetingHud.VoteStates.Results)
+		{
+			return;
+		}
+		this.state = MeetingHud.VoteStates.Results;
+		this.resultsStartedAt = this.discussionTimer;
+		this.exiledPlayer = exiled;
+		this.wasTie = tie;
+		this.SkipVoteButton.gameObject.SetActive(false);
+		this.SkippedVoting.gameObject.SetActive(true);
+		AmongUsClient.Instance.DisconnectHandlers.Remove(this);
+		this.PopulateResults(states);
+		this.SetupProceedButton();
+	}
+
+	public bool Select(int suspectStateIdx)
+	{
+		if (this.discussionTimer < (float)PlayerControl.GameOptions.DiscussionTime)
+		{
+			return false;
+		}
+		if (PlayerControl.LocalPlayer.Data.IsDead)
+		{
+			return false;
+		}
+		SoundManager.Instance.PlaySound(this.VoteSound, false, 1f).volume = 0.8f;
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea = this.playerStates[i];
+			if (suspectStateIdx != (int)playerVoteArea.TargetPlayerId)
+			{
+				playerVoteArea.ClearButtons();
+			}
+		}
+		if (suspectStateIdx != -1)
+		{
+			this.SkipVoteButton.ClearButtons();
+		}
+		return true;
+	}
+
+	public void Confirm(sbyte suspectStateIdx)
+	{
+		if (PlayerControl.LocalPlayer.Data.IsDead)
+		{
+			return;
+		}
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea = this.playerStates[i];
+			playerVoteArea.ClearButtons();
+			playerVoteArea.voteComplete = true;
+		}
+		this.SkipVoteButton.ClearButtons();
+		this.SkipVoteButton.voteComplete = true;
+		this.SkipVoteButton.gameObject.SetActive(false);
+		MeetingHud.VoteStates voteStates = this.state;
+		if (voteStates != MeetingHud.VoteStates.NotVoted)
+		{
+			return;
+		}
+		this.state = MeetingHud.VoteStates.Voted;
+		this.CmdCastVote(PlayerControl.LocalPlayer.PlayerId, suspectStateIdx);
+	}
+
+	public void HandleDisconnect(PlayerControl pc, DisconnectReasons reason)
+	{
+		if (!AmongUsClient.Instance.AmHost)
+		{
+			return;
+		}
+		int num = this.playerStates.IndexOf((PlayerVoteArea pv) => pv.TargetPlayerId == (sbyte)pc.PlayerId);
+		PlayerVoteArea playerVoteArea = this.playerStates[num];
+		playerVoteArea.isDead = true;
+		playerVoteArea.Overlay.gameObject.SetActive(true);
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea2 = this.playerStates[i];
+			if (!playerVoteArea2.isDead && playerVoteArea2.didVote && playerVoteArea2.votedFor == (sbyte)pc.PlayerId)
+			{
+				playerVoteArea2.UnsetVote();
+				base.SetDirtyBit(1U << i);
+				GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById((byte)playerVoteArea2.TargetPlayerId);
+				if (playerById != null)
+				{
+					int clientIdFromCharacter = AmongUsClient.Instance.GetClientIdFromCharacter(playerById.Object);
+					if (clientIdFromCharacter != -1)
+					{
+						this.RpcClearVote(clientIdFromCharacter);
+					}
+				}
+			}
+		}
+		base.SetDirtyBit(1U << num);
+		this.CheckForEndVoting();
+		if (this.state == MeetingHud.VoteStates.Results)
+		{
+			this.SetupProceedButton();
+		}
+	}
+
+	public void HandleDisconnect()
+	{
+	}
+
+	private void ForceSkipAll()
+	{
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea = this.playerStates[i];
+			if (!playerVoteArea.didVote)
+			{
+				playerVoteArea.didVote = true;
+				playerVoteArea.votedFor = -2;
+				base.SetDirtyBit(1U << i);
+			}
+		}
+		this.CheckForEndVoting();
+	}
+
+	public void CastVote(byte srcPlayerId, sbyte suspectPlayerId)
+	{
+		int num = this.playerStates.IndexOf((PlayerVoteArea pv) => pv.TargetPlayerId == (sbyte)srcPlayerId);
+		PlayerVoteArea playerVoteArea = this.playerStates[num];
+		if (!playerVoteArea.isDead && !playerVoteArea.didVote)
+		{
+			if (PlayerControl.LocalPlayer.PlayerId == srcPlayerId || AmongUsClient.Instance.GameMode != GameModes.LocalGame)
+			{
+				SoundManager.Instance.PlaySound(this.VoteLockinSound, false, 1f);
+			}
+			playerVoteArea.SetVote(suspectPlayerId);
+			base.SetDirtyBit(1U << num);
+			this.CheckForEndVoting();
+			PlayerControl.LocalPlayer.RpcSendChatNote(srcPlayerId, ChatNoteTypes.DidVote);
+		}
+	}
+
+	public void ClearVote()
+	{
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			this.playerStates[i].voteComplete = false;
+		}
+		this.SkipVoteButton.voteComplete = false;
+		this.SkipVoteButton.gameObject.SetActive(true);
+		this.state = MeetingHud.VoteStates.NotVoted;
+	}
+
+	private void CheckForEndVoting()
+	{
+		if (this.playerStates.All((PlayerVoteArea ps) => ps.isDead || ps.didVote))
+		{
+			byte[] self = this.CalculateVotes();
+			bool tie;
+			int maxIdx = self.IndexOfMax((byte p) => (int)p, out tie) - 1;
+			GameData.PlayerInfo exiled = GameData.Instance.AllPlayers.FirstOrDefault((GameData.PlayerInfo v) => (int)v.PlayerId == maxIdx);
+			byte[] states = (from ps in this.playerStates
+			select ps.GetState()).ToArray<byte>();
+			this.RpcVotingComplete(states, exiled, tie);
+		}
+	}
+
+	private byte[] CalculateVotes()
+	{
+		byte[] array = new byte[11];
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea = this.playerStates[i];
+			if (playerVoteArea.didVote)
+			{
+				int num = (int)(playerVoteArea.votedFor + 1);
+				if (num >= 0 && num < array.Length)
+				{
+					byte[] array2 = array;
+					int num2 = num;
+					array2[num2] += 1;
+				}
+			}
+		}
+		return array;
+	}
+
+	public override bool Serialize(MessageWriter writer, bool initialState)
+	{
+		if (this.playerStates == null)
+		{
+			return false;
+		}
+		if (initialState)
+		{
+			for (int i = 0; i < this.playerStates.Length; i++)
+			{
+				this.playerStates[i].Serialize(writer);
+			}
+		}
+		else
+		{
+			writer.WritePacked(this.DirtyBits);
+			for (int j = 0; j < this.playerStates.Length; j++)
+			{
+				if ((this.DirtyBits & 1U << j) != 0U)
+				{
+					this.playerStates[j].Serialize(writer);
+				}
+			}
+		}
+		this.DirtyBits = 0U;
+		return true;
+	}
+
+	public override void Deserialize(MessageReader reader, bool initialState)
+	{
+		if (initialState)
+		{
+			MeetingHud.Instance = this;
+			this.PopulateButtons(0);
+			for (int i = 0; i < this.playerStates.Length; i++)
+			{
+				PlayerVoteArea playerVoteArea = this.playerStates[i];
+				playerVoteArea.Deserialize(reader);
+				if (playerVoteArea.didReport)
+				{
+					this.reporterId = (byte)playerVoteArea.TargetPlayerId;
+				}
+			}
+			return;
+		}
+		uint num = reader.ReadPackedUInt32();
+		for (int j = 0; j < this.playerStates.Length; j++)
+		{
+			if ((num & 1U << j) != 0U)
+			{
+				this.playerStates[j].Deserialize(reader);
+			}
+		}
+	}
+
+	public void HandleProceed()
+	{
+		if (!AmongUsClient.Instance.AmHost)
+		{
+			base.StartCoroutine(Effects.Shake(this.HostIcon.transform, 0.75f, 0.25f));
+			return;
+		}
+		if (this.state != MeetingHud.VoteStates.Results)
+		{
+			return;
+		}
+		this.state = MeetingHud.VoteStates.Proceeding;
+		this.RpcClose();
+	}
+
+	private void SetupProceedButton()
+	{
+		if (AmongUsClient.Instance.GameMode != GameModes.OnlineGame)
+		{
+			this.TimerText.gameObject.SetActive(false);
+			this.ProceedButton.gameObject.SetActive(true);
+			this.HostIcon.gameObject.SetActive(true);
+			GameData.PlayerInfo host = GameData.Instance.GetHost();
+			if (host != null)
+			{
+				PlayerControl.SetPlayerMaterialColors((int)host.ColorId, this.HostIcon);
+				return;
+			}
+			this.HostIcon.enabled = false;
+		}
+	}
+
+	private void PopulateResults(byte[] states)
+	{
+		DestroyableSingleton<Telemetry>.Instance.WriteMeetingEnded(states, this.discussionTimer);
+		this.TitleText.Text = "Voting Results";
+		int num = 0;
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			PlayerVoteArea playerVoteArea = this.playerStates[i];
+			playerVoteArea.ClearForResults();
+			int num2 = 0;
+			for (int j = 0; j < this.playerStates.Length; j++)
+			{
+				if (!states[j].HasAnyBit(128))
+				{
+					GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById((byte)this.playerStates[j].TargetPlayerId);
+					int num3 = (int)((states[j] & 15) - 1);
+					if (num3 == (int)playerVoteArea.TargetPlayerId)
+					{
+						SpriteRenderer spriteRenderer = UnityEngine.Object.Instantiate<SpriteRenderer>(this.PlayerVotePrefab);
+						PlayerControl.SetPlayerMaterialColors((int)playerById.ColorId, spriteRenderer);
+						spriteRenderer.transform.SetParent(playerVoteArea.transform);
+						spriteRenderer.transform.localPosition = this.CounterOrigin + new Vector3(this.CounterOffsets.x * (float)num2, 0f, 0f);
+						spriteRenderer.transform.localScale = Vector3.zero;
+						base.StartCoroutine(Effects.Bloop((float)num2 * 0.5f, spriteRenderer.transform, 0.5f));
+						num2++;
+					}
+					else if (i == 0 && num3 == -1)
+					{
+						SpriteRenderer spriteRenderer2 = UnityEngine.Object.Instantiate<SpriteRenderer>(this.PlayerVotePrefab);
+						PlayerControl.SetPlayerMaterialColors((int)playerById.ColorId, spriteRenderer2);
+						spriteRenderer2.transform.SetParent(this.SkippedVoting.transform);
+						spriteRenderer2.transform.localPosition = this.CounterOrigin + new Vector3(this.CounterOffsets.x * (float)num, 0f, 0f);
+						spriteRenderer2.transform.localScale = Vector3.zero;
+						base.StartCoroutine(Effects.Bloop((float)num * 0.5f, spriteRenderer2.transform, 0.5f));
+						num++;
+					}
+				}
+			}
+		}
+	}
+
+	private void UpdateButtons()
+	{
+		if (PlayerControl.LocalPlayer.Data.IsDead && !this.amDead)
+		{
+			this.SetForegroundForDead();
+		}
+		if (AmongUsClient.Instance.AmHost)
+		{
+			for (int i = 0; i < this.playerStates.Length; i++)
+			{
+				PlayerVoteArea playerVoteArea = this.playerStates[i];
+				GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById((byte)playerVoteArea.TargetPlayerId);
+				if (playerById == null)
+				{
+					playerVoteArea.SetDisabled();
+				}
+				else
+				{
+					bool flag = playerById.Disconnected || playerById.IsDead;
+					if (flag != playerVoteArea.isDead)
+					{
+						playerVoteArea.SetDead(playerById.PlayerId == PlayerControl.LocalPlayer.PlayerId, this.reporterId == playerById.PlayerId, flag);
+						base.SetDirtyBit(1U << i);
+					}
+				}
+			}
+		}
+	}
+
+	private void PopulateButtons(byte reporter)
+	{
+		this.playerStates = new PlayerVoteArea[GameData.Instance.PlayerCount];
+		for (int i = 0; i < this.playerStates.Length; i++)
+		{
+			GameData.PlayerInfo playerInfo = GameData.Instance.AllPlayers[i];
+			PlayerVoteArea playerVoteArea = this.playerStates[i] = this.CreateButton(playerInfo);
+			playerVoteArea.Parent = this;
+			playerVoteArea.TargetPlayerId = (sbyte)playerInfo.PlayerId;
+			playerVoteArea.SetDead(playerInfo.PlayerId == PlayerControl.LocalPlayer.PlayerId, reporter == playerInfo.PlayerId, playerInfo.Disconnected || playerInfo.IsDead);
+		}
+		this.SortButtons();
+	}
+
+	private void SortButtons()
+	{
+		PlayerVoteArea[] array = this.playerStates.OrderBy(delegate(PlayerVoteArea p)
+		{
+			if (!p.isDead)
+			{
+				return 0;
+			}
+			return 50;
+		}).ThenBy((PlayerVoteArea p) => p.TargetPlayerId).ToArray<PlayerVoteArea>();
+		for (int i = 0; i < array.Length; i++)
+		{
+			int num = i % 2;
+			int num2 = i / 2;
+			array[i].transform.localPosition = this.VoteOrigin + new Vector3(this.VoteButtonOffsets.x * (float)num, this.VoteButtonOffsets.y * (float)num2, -1f);
+		}
+	}
+
+	private PlayerVoteArea CreateButton(GameData.PlayerInfo playerInfo)
+	{
+		PlayerVoteArea playerVoteArea = UnityEngine.Object.Instantiate<PlayerVoteArea>(this.PlayerButtonPrefab, this.ButtonParent.transform);
+		PlayerControl.SetPlayerMaterialColors((int)playerInfo.ColorId, playerVoteArea.PlayerIcon);
+		playerVoteArea.NameText.Text = playerInfo.PlayerName;
+		bool flag = PlayerControl.LocalPlayer.Data.IsImpostor && playerInfo.IsImpostor;
+		playerVoteArea.NameText.Color = (flag ? Palette.ImpostorRed : Color.white);
+		playerVoteArea.transform.localScale = Vector3.one;
+		return playerVoteArea;
+	}
+
+	public bool DidVote(byte playerId)
+	{
+		return this.playerStates.First((PlayerVoteArea p) => p.TargetPlayerId == (sbyte)playerId).didVote;
+	}
+
+	public int GetVotesRemaining()
+	{
+		int result;
+		try
+		{
+			result = this.playerStates.Count((PlayerVoteArea ps) => !ps.isDead && !ps.didVote);
+		}
+		catch
+		{
+			result = 0;
+		}
+		return result;
+	}
+
+	public void RpcClose()
+	{
+		if (AmongUsClient.Instance.AmClient)
+		{
+			this.Close();
+		}
+		AmongUsClient.Instance.SendRpc(this.NetId, 0, SendOption.Reliable);
+	}
+
+	public void CmdCastVote(byte playerId, sbyte suspectIdx)
+	{
+		if (AmongUsClient.Instance.AmHost)
+		{
+			this.CastVote(playerId, suspectIdx);
+			return;
+		}
+		MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 2, SendOption.Reliable, AmongUsClient.Instance.HostId);
+		messageWriter.Write(playerId);
+		messageWriter.Write(suspectIdx);
+		AmongUsClient.Instance.FinishRpcImmediately(messageWriter);
+	}
+
+	private void RpcVotingComplete(byte[] states, GameData.PlayerInfo exiled, bool tie)
+	{
+		if (AmongUsClient.Instance.AmClient)
+		{
+			this.VotingComplete(states, exiled, tie);
+		}
+		MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 1, SendOption.Reliable);
+		messageWriter.WriteBytesAndSize(states);
+		messageWriter.Write((exiled != null) ? exiled.PlayerId : byte.MaxValue);
+		messageWriter.Write(tie);
+		messageWriter.EndMessage();
+	}
+
+	private void RpcClearVote(int clientId)
+	{
+		if (AmongUsClient.Instance.ClientId == clientId)
+		{
+			this.ClearVote();
+			return;
+		}
+		MessageWriter msg = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 3, SendOption.Reliable, clientId);
+		AmongUsClient.Instance.FinishRpcImmediately(msg);
+	}
+
+	public override void HandleRpc(byte callId, MessageReader reader)
+	{
+		switch (callId)
+		{
+		case 0:
+			this.Close();
+			return;
+		case 1:
+		{
+			byte[] states = reader.ReadBytesAndSize();
+			GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(reader.ReadByte());
+			bool tie = reader.ReadBoolean();
+			this.VotingComplete(states, playerById, tie);
+			return;
+		}
+		case 2:
+		{
+			byte srcPlayerId = reader.ReadByte();
+			sbyte suspectPlayerId = reader.ReadSByte();
+			this.CastVote(srcPlayerId, suspectPlayerId);
+			return;
+		}
+		case 3:
+			this.ClearVote();
+			return;
+		default:
+			return;
+		}
+	}
+}