diff options
Diffstat (limited to 'Client/Assembly-CSharp/PlayerControl.cs')
| -rw-r--r-- | Client/Assembly-CSharp/PlayerControl.cs | 1470 |
1 files changed, 1470 insertions, 0 deletions
diff --git a/Client/Assembly-CSharp/PlayerControl.cs b/Client/Assembly-CSharp/PlayerControl.cs new file mode 100644 index 0000000..f0e5fbc --- /dev/null +++ b/Client/Assembly-CSharp/PlayerControl.cs @@ -0,0 +1,1470 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using Assets.CoreScripts; +using Hazel; +using InnerNet; +using PowerTools; +using UnityEngine; + +public class PlayerControl : InnerNetObject +{ + public bool CanMove + { + get + { + return this.moveable && !Minigame.Instance && (!DestroyableSingleton<HudManager>.InstanceExists || (!DestroyableSingleton<HudManager>.Instance.Chat.IsOpen && !DestroyableSingleton<HudManager>.Instance.KillOverlay.IsOpen && !DestroyableSingleton<HudManager>.Instance.GameMenu.IsOpen)) && (!MapBehaviour.Instance || !MapBehaviour.Instance.IsOpenStopped) && !MeetingHud.Instance && !CustomPlayerMenu.Instance && !ExileController.Instance && !IntroCutscene.Instance; + } + } + + public GameData.PlayerInfo Data + { + get + { + if (this._cachedData == null) + { + if (!GameData.Instance) + { + return null; + } + this._cachedData = GameData.Instance.GetPlayerById(this.PlayerId); + } + return this._cachedData; + } + } + + public bool Visible + { + get + { + return this.myRend.enabled; + } + set + { + this.myRend.enabled = value; + this.MyPhysics.Skin.Visible = value; + this.HatRenderer.enabled = value; + this.nameText.gameObject.SetActive(value); + } + } + + public byte PlayerId = byte.MaxValue; + + public float MaxReportDistance = 5f; + + public bool moveable = true; + + public bool inVent; + + public static PlayerControl LocalPlayer; + + private GameData.PlayerInfo _cachedData; + + public AudioSource FootSteps; + + public AudioClip KillSfx; + + public KillAnimation[] KillAnimations; + + [SerializeField] + private float killTimer; + + public int RemainingEmergencies; + + public TextRenderer nameText; + + public LightSource LightPrefab; + + private LightSource myLight; + + [HideInInspector] + public Collider2D Collider; + + [HideInInspector] + public PlayerPhysics MyPhysics; + + [HideInInspector] + public CustomNetworkTransform NetTransform; + + public PetBehaviour CurrentPet; + + public SpriteRenderer HatRenderer; + + private SpriteRenderer myRend; + + private Collider2D[] hitBuffer = new Collider2D[20]; + + public static GameOptionsData GameOptions = new GameOptionsData(); + + public List<PlayerTask> myTasks = new List<PlayerTask>(); + + [NonSerialized] + public uint TaskIdCount; + + public SpriteAnim[] ScannerAnims; + + public SpriteRenderer[] ScannersImages; + + public AudioClip[] VentMoveSounds; + + public AudioClip VentEnterSound; + + private IUsable closest; + + private bool isNew = true; + + public float crewStreak; + + public static List<PlayerControl> AllPlayerControls = new List<PlayerControl>(); + + private Dictionary<Collider2D, IUsable> cache = new Dictionary<Collider2D, IUsable>(PlayerControl.ColliderComparer.Instance); + + private List<IUsable> itemsInRange = new List<IUsable>(); + + private List<IUsable> newItemsInRange = new List<IUsable>(); + + private byte scannerCount; + + private int LastStartCounter; + + public class ColliderComparer : IEqualityComparer<Collider2D> + { + public static readonly PlayerControl.ColliderComparer Instance = new PlayerControl.ColliderComparer(); + + public bool Equals(Collider2D x, Collider2D y) + { + return x == y; + } + + public int GetHashCode(Collider2D obj) + { + return obj.GetInstanceID(); + } + } + + public class UsableComparer : IEqualityComparer<IUsable> + { + public static readonly PlayerControl.UsableComparer Instance = new PlayerControl.UsableComparer(); + + public bool Equals(IUsable x, IUsable y) + { + return x == y; + } + + public int GetHashCode(IUsable obj) + { + return obj.GetHashCode(); + } + } + + public enum RpcCalls : byte + { + PlayAnimation, + CompleteTask, + SyncSettings, + SetInfected, + Exiled, + CheckName, + SetName, + CheckColor, + SetColor, + SetHat, + SetSkin, + ReportDeadBody, + MurderPlayer, + SendChat, + TimesImpostor, + StartMeeting, + SetScanner, + SendChatNote, + SetPet, + SetStartCounter + } + + public void SetKillTimer(float time) + { + this.killTimer = time; + if (PlayerControl.GameOptions.KillCooldown > 0f) + { + DestroyableSingleton<HudManager>.Instance.KillButton.SetCoolDown(this.killTimer, PlayerControl.GameOptions.KillCooldown); + return; + } + DestroyableSingleton<HudManager>.Instance.KillButton.SetCoolDown(0f, PlayerControl.GameOptions.KillCooldown); + } + + private void Awake() + { + this.myRend = base.GetComponent<SpriteRenderer>(); + this.MyPhysics = base.GetComponent<PlayerPhysics>(); + this.NetTransform = base.GetComponent<CustomNetworkTransform>(); + this.Collider = base.GetComponent<Collider2D>(); + PlayerControl.AllPlayerControls.Add(this); + } + + private void Start() + { + this.RemainingEmergencies = PlayerControl.GameOptions.NumEmergencyMeetings; + if (base.AmOwner) + { + this.myLight = UnityEngine.Object.Instantiate<LightSource>(this.LightPrefab); + this.myLight.transform.SetParent(base.transform); + this.myLight.transform.localPosition = this.Collider.offset; + PlayerControl.LocalPlayer = this; + Camera.main.GetComponent<FollowerCamera>().SetTarget(this); + this.SetName(SaveManager.PlayerName); + this.SetColor(SaveManager.BodyColor); + this.CmdCheckName(SaveManager.PlayerName); + this.CmdCheckColor(SaveManager.BodyColor); + this.RpcSetPet(SaveManager.LastPet); + this.RpcSetHat(SaveManager.LastHat); + this.RpcSetSkin(SaveManager.LastSkin); + this.RpcSetTimesImpostor(StatsManager.Instance.CrewmateStreak); + } + else + { + base.StartCoroutine(this.ClientInitialize()); + } + if (this.isNew) + { + this.isNew = false; + base.StartCoroutine(this.MyPhysics.CoSpawnPlayer(LobbyBehaviour.Instance)); + } + } + + private IEnumerator ClientInitialize() + { + this.Visible = false; + while (!GameData.Instance) + { + yield return null; + } + while (this.Data == null) + { + yield return null; + } + while (string.IsNullOrEmpty(this.Data.PlayerName)) + { + yield return null; + } + this.SetName(this.Data.PlayerName); + this.SetColor(this.Data.ColorId); + this.SetHat(this.Data.HatId); + this.SetSkin(this.Data.SkinId); + this.SetPet(this.Data.PetId); + this.Visible = true; + yield break; + } + + public override void OnDestroy() + { + if (this.CurrentPet) + { + UnityEngine.Object.Destroy(this.CurrentPet.gameObject); + } + PlayerControl.AllPlayerControls.Remove(this); + base.OnDestroy(); + } + + private void FixedUpdate() + { + if (!GameData.Instance) + { + return; + } + GameData.PlayerInfo data = this.Data; + if (data == null) + { + return; + } + if (data.IsDead && PlayerControl.LocalPlayer) + { + this.Visible = PlayerControl.LocalPlayer.Data.IsDead; + } + if (base.AmOwner) + { + if (ShipStatus.Instance) + { + this.myLight.LightRadius = ShipStatus.Instance.CalculateLightRadius(data); + } + if (data.IsImpostor && this.CanMove && !data.IsDead) + { + this.SetKillTimer(Mathf.Max(0f, this.killTimer - Time.fixedDeltaTime)); + PlayerControl target = this.FindClosestTarget(); + DestroyableSingleton<HudManager>.Instance.KillButton.SetTarget(target); + } + else + { + DestroyableSingleton<HudManager>.Instance.KillButton.SetTarget(null); + } + if (this.CanMove || this.inVent) + { + this.newItemsInRange.Clear(); + bool flag = (PlayerControl.GameOptions.GhostsDoTasks || !data.IsDead) && (!AmongUsClient.Instance || !AmongUsClient.Instance.IsGameOver) && this.CanMove; + Vector2 truePosition = this.GetTruePosition(); + int num = Physics2D.OverlapCircleNonAlloc(truePosition, this.MaxReportDistance, this.hitBuffer, Constants.Usables); + IUsable usable = null; + float num2 = float.MaxValue; + bool flag2 = false; + for (int i = 0; i < num; i++) + { + Collider2D collider2D = this.hitBuffer[i]; + IUsable usable2; + if (!this.cache.TryGetValue(collider2D, out usable2)) + { + usable2 = (this.cache[collider2D] = collider2D.GetComponent<IUsable>()); + } + if (usable2 != null && (flag || this.inVent)) + { + bool flag3; + bool flag4; + float num3 = usable2.CanUse(data, out flag3, out flag4); + if (flag3 || flag4) + { + this.newItemsInRange.Add(usable2); + } + if (flag3 && num3 < num2) + { + num2 = num3; + usable = usable2; + } + } + if (flag && !data.IsDead && !flag2 && collider2D.tag == "DeadBody") + { + DeadBody component = collider2D.GetComponent<DeadBody>(); + if (!PhysicsHelpers.AnythingBetween(truePosition, component.TruePosition, Constants.ShipAndObjectsMask, false)) + { + flag2 = true; + } + } + } + for (int l = this.itemsInRange.Count - 1; l > -1; l--) + { + IUsable item = this.itemsInRange[l]; + int num4 = this.newItemsInRange.FindIndex((IUsable j) => j == item); + if (num4 == -1) + { + item.SetOutline(false, false); + this.itemsInRange.RemoveAt(l); + } + else + { + this.newItemsInRange.RemoveAt(num4); + item.SetOutline(true, usable == item); + } + } + for (int k = 0; k < this.newItemsInRange.Count; k++) + { + IUsable usable3 = this.newItemsInRange[k]; + usable3.SetOutline(true, usable == usable3); + this.itemsInRange.Add(usable3); + } + this.closest = usable; + DestroyableSingleton<HudManager>.Instance.UseButton.SetTarget(usable); + DestroyableSingleton<HudManager>.Instance.ReportButton.SetActive(flag2); + return; + } + this.closest = null; + DestroyableSingleton<HudManager>.Instance.UseButton.SetTarget(null); + DestroyableSingleton<HudManager>.Instance.ReportButton.SetActive(false); + } + } + + public void UseClosest() + { + if (this.closest != null) + { + this.closest.Use(); + } + this.closest = null; + DestroyableSingleton<HudManager>.Instance.UseButton.SetTarget(null); + } + + public void ReportClosest() + { + if (AmongUsClient.Instance.IsGameOver) + { + return; + } + if (PlayerControl.LocalPlayer.Data.IsDead) + { + return; + } + foreach (Collider2D collider2D in Physics2D.OverlapCircleAll(base.transform.position, this.MaxReportDistance, Constants.NotShipMask)) + { + if (!(collider2D.tag != "DeadBody")) + { + DeadBody component = collider2D.GetComponent<DeadBody>(); + if (component && !component.Reported) + { + component.OnClick(); + if (component.Reported) + { + break; + } + } + } + } + } + + public void PlayStepSound() + { + if (!Constants.ShouldPlaySfx()) + { + return; + } + if (DestroyableSingleton<HudManager>.InstanceExists && PlayerControl.LocalPlayer == this) + { + ShipRoom lastRoom = DestroyableSingleton<HudManager>.Instance.roomTracker.LastRoom; + if (lastRoom && lastRoom.FootStepSounds) + { + AudioClip clip = lastRoom.FootStepSounds.Random(); + this.FootSteps.clip = clip; + this.FootSteps.Play(); + } + } + } + + private void SetScanner(bool on, byte cnt) + { + if (cnt < this.scannerCount) + { + return; + } + this.scannerCount = cnt; + for (int i = 0; i < this.ScannerAnims.Length; i++) + { + SpriteAnim spriteAnim = this.ScannerAnims[i]; + if (on && !this.Data.IsDead) + { + spriteAnim.gameObject.SetActive(true); + spriteAnim.Play(null, 1f); + this.ScannersImages[i].flipX = !this.myRend.flipX; + } + else + { + if (spriteAnim.isActiveAndEnabled) + { + spriteAnim.Stop(); + } + spriteAnim.gameObject.SetActive(false); + } + } + } + + public Vector2 GetTruePosition() + { + return base.transform.position + this.Collider.offset; + } + + private PlayerControl FindClosestTarget() + { + PlayerControl result = null; + float num = GameOptionsData.KillDistances[Mathf.Clamp(PlayerControl.GameOptions.KillDistance, 0, 2)]; + if (!ShipStatus.Instance) + { + return null; + } + Vector2 truePosition = this.GetTruePosition(); + 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 != this.PlayerId && !playerInfo.IsDead && !playerInfo.IsImpostor) + { + 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 void SetTasks(byte[] tasks) + { + base.StartCoroutine(this.CoSetTasks(tasks)); + } + + private IEnumerator CoSetTasks(byte[] tasks) + { + while (!ShipStatus.Instance) + { + yield return null; + } + if (base.AmOwner) + { + DestroyableSingleton<HudManager>.Instance.TaskStuff.SetActive(true); + StatsManager instance = StatsManager.Instance; + uint num = instance.GamesStarted; + instance.GamesStarted = num + 1U; + if (this.Data.IsImpostor) + { + StatsManager instance2 = StatsManager.Instance; + num = instance2.TimesImpostor; + instance2.TimesImpostor = num + 1U; + StatsManager.Instance.CrewmateStreak = 0U; + } + else + { + StatsManager instance3 = StatsManager.Instance; + num = instance3.TimesCrewmate; + instance3.TimesCrewmate = num + 1U; + StatsManager instance4 = StatsManager.Instance; + num = instance4.CrewmateStreak; + instance4.CrewmateStreak = num + 1U; + DestroyableSingleton<HudManager>.Instance.KillButton.gameObject.SetActive(false); + } + DestroyableSingleton<Telemetry>.Instance.StartGame(SaveManager.SendName, AmongUsClient.Instance.AmHost, GameData.Instance.PlayerCount, PlayerControl.GameOptions.NumImpostors, AmongUsClient.Instance.GameMode, StatsManager.Instance.TimesImpostor, StatsManager.Instance.GamesStarted, StatsManager.Instance.CrewmateStreak); + } + foreach (byte idx in tasks) + { + NormalPlayerTask normalPlayerTask = UnityEngine.Object.Instantiate<NormalPlayerTask>(ShipStatus.Instance.GetTaskById(idx), base.transform); + PlayerTask playerTask = normalPlayerTask; + uint num = this.TaskIdCount; + this.TaskIdCount = num + 1U; + playerTask.Id = num; + normalPlayerTask.Owner = this; + normalPlayerTask.Initialize(); + this.myTasks.Add(normalPlayerTask); + } + yield break; + } + + public void AddSystemTask(SystemTypes system) + { + PlayerTask original; + if (system <= SystemTypes.Electrical) + { + if (system != SystemTypes.Reactor) + { + if (system != SystemTypes.Electrical) + { + return; + } + original = ShipStatus.Instance.SpecialTasks[1]; + } + else + { + original = ShipStatus.Instance.SpecialTasks[0]; + } + } + else if (system != SystemTypes.LifeSupp) + { + if (system != SystemTypes.Comms) + { + return; + } + original = ShipStatus.Instance.SpecialTasks[2]; + } + else + { + original = ShipStatus.Instance.SpecialTasks[3]; + } + PlayerControl localPlayer = PlayerControl.LocalPlayer; + PlayerTask playerTask = UnityEngine.Object.Instantiate<PlayerTask>(original, localPlayer.transform); + PlayerTask playerTask2 = playerTask; + PlayerControl playerControl = localPlayer; + uint taskIdCount = playerControl.TaskIdCount; + playerControl.TaskIdCount = taskIdCount + 1U; + playerTask2.Id = (uint)((byte)taskIdCount); + playerTask.Owner = localPlayer; + playerTask.Initialize(); + localPlayer.myTasks.Add(playerTask); + } + + public void RemoveTask(PlayerTask task) + { + task.OnRemove(); + this.myTasks.Remove(task); + GameData.Instance.TutOnlyRemoveTask(this.PlayerId, task.Id); + DestroyableSingleton<HudManager>.Instance.UseButton.SetTarget(null); + UnityEngine.Object.Destroy(task.gameObject); + } + + private void ClearTasks() + { + for (int i = 0; i < this.myTasks.Count; i++) + { + PlayerTask playerTask = this.myTasks[i]; + playerTask.OnRemove(); + UnityEngine.Object.Destroy(playerTask.gameObject); + } + this.myTasks.Clear(); + } + + public void RemoveInfected() + { + GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(this.PlayerId); + if (playerById.IsImpostor) + { + playerById.Object.nameText.Color = Color.white; + playerById.IsImpostor = false; + this.myTasks.RemoveAt(0); + DestroyableSingleton<HudManager>.Instance.KillButton.gameObject.SetActive(false); + } + } + + public void Die(DeathReason reason) + { + if (!DestroyableSingleton<TutorialManager>.InstanceExists) + { + StatsManager.Instance.LastGameStarted = DateTime.MinValue; + StatsManager instance = StatsManager.Instance; + float banPoints = instance.BanPoints; + instance.BanPoints = banPoints - 1f; + } + TempData.LastDeathReason = reason; + if (this.CurrentPet) + { + this.CurrentPet.SetMourning(); + } + this.Data.IsDead = true; + base.gameObject.layer = LayerMask.NameToLayer("Ghost"); + this.nameText.GetComponent<MeshRenderer>().material.SetInt("_Mask", 0); + if (base.AmOwner) + { + DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(true); + } + } + + public void Revive() + { + this.Data.IsDead = false; + base.gameObject.layer = LayerMask.NameToLayer("Players"); + this.MyPhysics.ResetAnim(true); + if (this.CurrentPet) + { + this.CurrentPet.Source = this; + } + this.nameText.GetComponent<MeshRenderer>().material.SetInt("_Mask", 4); + if (base.AmOwner) + { + DestroyableSingleton<HudManager>.Instance.KillButton.gameObject.SetActive(this.Data.IsImpostor); + DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed(); + DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(false); + } + } + + public void PlayAnimation(byte animType) + { + if (animType == 1) + { + ShipStatus.Instance.StartShields(); + return; + } + if (animType == 6) + { + ShipStatus.Instance.FireWeapon(); + return; + } + if (animType - 9 > 1) + { + return; + } + ShipStatus.Instance.OpenHatch(); + } + + public void CompleteTask(uint idx) + { + PlayerTask playerTask = this.myTasks.Find((PlayerTask p) => p.Id == idx); + if (playerTask) + { + GameData.Instance.CompleteTask(this, idx); + playerTask.Complete(); + DestroyableSingleton<Telemetry>.Instance.WriteCompleteTask(this.PlayerId, playerTask.TaskType); + return; + } + Debug.LogWarning(this.PlayerId + ": Server didn't have task: " + idx); + } + + public void SetInfected(byte[] infected) + { + if (!GameData.Instance) + { + Debug.Log("No game data instance."); + } + StatsManager instance = StatsManager.Instance; + float banPoints = instance.BanPoints; + instance.BanPoints = banPoints + 1f; + StatsManager.Instance.LastGameStarted = DateTime.UtcNow; + for (int i = 0; i < infected.Length; i++) + { + GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(infected[i]); + if (playerById != null) + { + playerById.IsImpostor = true; + } + else + { + Debug.LogError("Couldn't set impostor: " + infected[i]); + } + } + DestroyableSingleton<HudManager>.Instance.MapButton.gameObject.SetActive(true); + DestroyableSingleton<HudManager>.Instance.ReportButton.gameObject.SetActive(true); + PlayerControl.LocalPlayer.RemainingEmergencies = PlayerControl.GameOptions.NumEmergencyMeetings; + GameData.PlayerInfo data = PlayerControl.LocalPlayer.Data; + if (data.IsImpostor) + { + ImportantTextTask importantTextTask = new GameObject("_Player").AddComponent<ImportantTextTask>(); + importantTextTask.transform.SetParent(PlayerControl.LocalPlayer.transform, false); + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ImpostorTask, Array.Empty<object>()) + "\r\n[FFFFFFFF]" + DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.FakeTasks, Array.Empty<object>()); + this.myTasks.Insert(0, importantTextTask); + DestroyableSingleton<HudManager>.Instance.KillButton.gameObject.SetActive(true); + PlayerControl.LocalPlayer.SetKillTimer(10f); + for (int j = 0; j < infected.Length; j++) + { + GameData.PlayerInfo playerById2 = GameData.Instance.GetPlayerById(infected[j]); + if (playerById2 != null) + { + playerById2.Object.nameText.Color = Palette.ImpostorRed; + } + } + } + if (!DestroyableSingleton<TutorialManager>.InstanceExists) + { + List<PlayerControl> yourTeam; + if (data.IsImpostor) + { + yourTeam = (from pcd in GameData.Instance.AllPlayers + where !pcd.Disconnected + where pcd.IsImpostor + select pcd.Object).OrderBy(delegate(PlayerControl pc) + { + if (!(pc == PlayerControl.LocalPlayer)) + { + return 1; + } + return 0; + }).ToList<PlayerControl>(); + } + else + { + yourTeam = (from pcd in GameData.Instance.AllPlayers + where !pcd.Disconnected + select pcd.Object).OrderBy(delegate(PlayerControl pc) + { + if (!(pc == PlayerControl.LocalPlayer)) + { + return 1; + } + return 0; + }).ToList<PlayerControl>(); + } + base.StopAllCoroutines(); + DestroyableSingleton<HudManager>.Instance.StartCoroutine(DestroyableSingleton<HudManager>.Instance.CoShowIntro(yourTeam)); + } + } + + public void Exiled() + { + this.Die(DeathReason.Exile); + if (base.AmOwner) + { + StatsManager instance = StatsManager.Instance; + uint timesEjected = instance.TimesEjected; + instance.TimesEjected = timesEjected + 1U; + DestroyableSingleton<HudManager>.Instance.ShadowQuad.gameObject.SetActive(false); + ImportantTextTask importantTextTask = new GameObject("_Player").AddComponent<ImportantTextTask>(); + importantTextTask.transform.SetParent(base.transform, false); + if (this.Data.IsImpostor) + { + this.ClearTasks(); + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.GhostImpostor, Array.Empty<object>()); + } + else if (!PlayerControl.GameOptions.GhostsDoTasks) + { + this.ClearTasks(); + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.GhostIgnoreTasks, Array.Empty<object>()); + } + else + { + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.GhostDoTasks, Array.Empty<object>()); + } + this.myTasks.Insert(0, importantTextTask); + } + } + + public void CheckName(string name) + { + List<GameData.PlayerInfo> allPlayers = GameData.Instance.AllPlayers; + bool flag = allPlayers.Any((GameData.PlayerInfo i) => i.PlayerId != this.PlayerId && i.PlayerName.Equals(name, StringComparison.OrdinalIgnoreCase)); + if (flag) + { + for (int k = 1; k < 100; k++) + { + string text = name + " " + k; + flag = false; + for (int j = 0; j < allPlayers.Count; j++) + { + if (allPlayers[j].PlayerId != this.PlayerId && allPlayers[j].PlayerName.Equals(text, StringComparison.OrdinalIgnoreCase)) + { + flag = true; + break; + } + } + if (!flag) + { + name = text; + break; + } + } + } + this.RpcSetName(name); + GameData.Instance.UpdateName(this.PlayerId, name); + } + + public void SetName(string name) + { + if (GameData.Instance) + { + GameData.Instance.UpdateName(this.PlayerId, name); + } + base.gameObject.name = name; + this.nameText.Text = name; + this.nameText.GetComponent<MeshRenderer>().material.SetInt("_Mask", 4); + } + + public void CheckColor(byte bodyColor) + { + List<GameData.PlayerInfo> allPlayers = GameData.Instance.AllPlayers; + int num = 0; + while (num++ < 100 && allPlayers.Any((GameData.PlayerInfo p) => !p.Disconnected && p.PlayerId != this.PlayerId && p.ColorId == bodyColor)) + { + bodyColor = (byte)((int)(bodyColor + 1) % Palette.PlayerColors.Length); + } + this.RpcSetColor(bodyColor); + } + + public void SetHatAlpha(float a) + { + Color white = Color.white; + white.a = a; + this.HatRenderer.color = white; + } + + public void SetColor(byte bodyColor) + { + if (GameData.Instance) + { + GameData.Instance.UpdateColor(this.PlayerId, bodyColor); + } + if (this.myRend == null) + { + base.GetComponent<SpriteRenderer>(); + } + PlayerControl.SetPlayerMaterialColors((int)bodyColor, this.myRend); + if (this.CurrentPet) + { + PlayerControl.SetPlayerMaterialColors((int)bodyColor, this.CurrentPet.rend); + } + } + + public void SetSkin(uint skinId) + { + if (GameData.Instance) + { + GameData.Instance.UpdateSkin(this.PlayerId, skinId); + } + this.MyPhysics.SetSkin(skinId); + } + + public void SetHat(uint hatId) + { + if (GameData.Instance) + { + GameData.Instance.UpdateHat(this.PlayerId, hatId); + } + PlayerControl.SetHatImage(hatId, this.HatRenderer); + this.nameText.transform.localPosition = new Vector3(0f, (hatId == 0U) ? 0.7f : 1.05f, -0.5f); + } + + public void SetPet(uint petId) + { + if (this.CurrentPet) + { + UnityEngine.Object.Destroy(this.CurrentPet.gameObject); + } + this.CurrentPet = UnityEngine.Object.Instantiate<PetBehaviour>(DestroyableSingleton<HatManager>.Instance.GetPetById(petId)); + this.CurrentPet.transform.position = base.transform.position; + this.CurrentPet.Source = this; + GameData.PlayerInfo data = this.Data; + if (this.Data != null) + { + GameData.Instance.UpdatePet(this.PlayerId, petId); + this.Data.PetId = petId; + PlayerControl.SetPlayerMaterialColors((int)this.Data.ColorId, this.CurrentPet.rend); + } + } + + public static void SetPetImage(uint petId, int colorId, SpriteRenderer target) + { + if (!DestroyableSingleton<HatManager>.InstanceExists) + { + return; + } + PlayerControl.SetPetImage(DestroyableSingleton<HatManager>.Instance.GetPetById(petId), colorId, target); + } + + public static void SetPetImage(PetBehaviour pet, int colorId, SpriteRenderer target) + { + target.sprite = pet.rend.sprite; + if (target != pet.rend) + { + target.material = new Material(pet.rend.sharedMaterial); + PlayerControl.SetPlayerMaterialColors(colorId, target); + } + } + + public static void SetSkinImage(uint skinId, SpriteRenderer target) + { + if (!DestroyableSingleton<HatManager>.InstanceExists) + { + return; + } + PlayerControl.SetSkinImage(DestroyableSingleton<HatManager>.Instance.GetSkinById(skinId), target); + } + + public static void SetSkinImage(SkinData skin, SpriteRenderer target) + { + target.sprite = skin.IdleFrame; + } + + public static void SetHatImage(uint hatId, SpriteRenderer target) + { + if (!DestroyableSingleton<HatManager>.InstanceExists) + { + return; + } + PlayerControl.SetHatImage(DestroyableSingleton<HatManager>.Instance.GetHatById(hatId), target); + } + + public static void SetHatImage(HatBehaviour hat, SpriteRenderer target) + { + if (!target) + { + return; + } + if (hat) + { + target.sprite = hat.MainImage; + Vector3 localPosition = target.transform.localPosition; + localPosition.z = (hat.InFront ? -0.0001f : 0.0001f); + target.transform.localPosition = localPosition; + return; + } + string str = (!hat) ? "null" : hat.name; + Debug.LogError("Player: " + target.name + "\tHat: " + str); + } + + private void ReportDeadBody(GameData.PlayerInfo target) + { + if (AmongUsClient.Instance.IsGameOver) + { + return; + } + if (MeetingHud.Instance) + { + return; + } + if (target == null && PlayerControl.LocalPlayer.myTasks.Any(new Func<PlayerTask, bool>(PlayerTask.TaskIsEmergency))) + { + return; + } + if (this.Data.IsDead) + { + return; + } + MeetingRoomManager.Instance.AssignSelf(this, target); + if (!AmongUsClient.Instance.AmHost) + { + return; + } + if (ShipStatus.Instance.CheckTaskCompletion()) + { + return; + } + DestroyableSingleton<HudManager>.Instance.OpenMeetingRoom(this); + this.RpcStartMeeting(target); + } + + public IEnumerator CoStartMeeting(GameData.PlayerInfo target) + { + DestroyableSingleton<Telemetry>.Instance.WriteMeetingStarted(target == null); + while (!MeetingHud.Instance) + { + yield return null; + } + MeetingRoomManager.Instance.RemoveSelf(); + DeadBody[] array = UnityEngine.Object.FindObjectsOfType<DeadBody>(); + for (int i = 0; i < array.Length; i++) + { + UnityEngine.Object.Destroy(array[i].gameObject); + } + for (int j = 0; j < PlayerControl.AllPlayerControls.Count; j++) + { + PlayerControl playerControl = PlayerControl.AllPlayerControls[j]; + if (!playerControl.GetComponent<DummyBehaviour>().enabled) + { + playerControl.MyPhysics.ExitAllVents(); + playerControl.NetTransform.SnapTo(ShipStatus.Instance.GetSpawnLocation((int)playerControl.PlayerId, GameData.Instance.PlayerCount)); + } + } + if (base.AmOwner) + { + if (target != null) + { + StatsManager instance = StatsManager.Instance; + uint num = instance.BodiesReported; + instance.BodiesReported = num + 1U; + } + else + { + this.RemainingEmergencies--; + StatsManager instance2 = StatsManager.Instance; + uint num = instance2.EmergenciesCalled; + instance2.EmergenciesCalled = num + 1U; + } + } + if (MapBehaviour.Instance) + { + MapBehaviour.Instance.Close(); + } + if (Minigame.Instance) + { + Minigame.Instance.Close(); + } + KillAnimation.SetMovement(this, true); + MeetingHud.Instance.StartCoroutine(MeetingHud.Instance.CoIntro(this, target)); + yield break; + } + + public void MurderPlayer(PlayerControl target) + { + if (AmongUsClient.Instance.IsGameOver) + { + return; + } + if (!target || this.Data.IsDead || !this.Data.IsImpostor || this.Data.Disconnected) + { + Debug.LogWarning(string.Format("Bad kill from {0} to {1}", this.PlayerId, ((int)((target != null) ? new byte?(target.PlayerId) : null)) ?? -1)); + return; + } + GameData.PlayerInfo data = target.Data; + if (data != null && !data.IsDead) + { + if (base.AmOwner) + { + StatsManager instance = StatsManager.Instance; + uint num = instance.ImpostorKills; + instance.ImpostorKills = num + 1U; + if (Constants.ShouldPlaySfx()) + { + SoundManager.Instance.PlaySound(PlayerControl.LocalPlayer.KillSfx, false, 0.8f); + } + } + this.SetKillTimer(PlayerControl.GameOptions.KillCooldown); + DestroyableSingleton<Telemetry>.Instance.WriteMurder(this.PlayerId, target.PlayerId, target.transform.position); + target.gameObject.layer = LayerMask.NameToLayer("Ghost"); + if (target.AmOwner) + { + StatsManager instance2 = StatsManager.Instance; + uint num = instance2.TimesMurdered; + instance2.TimesMurdered = num + 1U; + if (Minigame.Instance) + { + Minigame.Instance.Close(); + Minigame.Instance.Close(); + } + DestroyableSingleton<HudManager>.Instance.ShadowQuad.gameObject.SetActive(false); + target.nameText.GetComponent<MeshRenderer>().material.SetInt("_Mask", 0); + DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowOne(this, data); + target.RpcSetScanner(false); + ImportantTextTask importantTextTask = new GameObject("_Player").AddComponent<ImportantTextTask>(); + importantTextTask.transform.SetParent(base.transform, false); + if (!PlayerControl.GameOptions.GhostsDoTasks) + { + target.ClearTasks(); + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.GhostIgnoreTasks, Array.Empty<object>()); + } + else + { + importantTextTask.Text = DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.GhostDoTasks, Array.Empty<object>()); + } + target.myTasks.Insert(0, importantTextTask); + } + this.MyPhysics.StartCoroutine(this.KillAnimations.Random<KillAnimation>().CoPerformKill(this, target)); + } + } + + public override bool Serialize(MessageWriter writer, bool initialState) + { + if (initialState) + { + writer.Write(this.isNew); + } + writer.Write(this.PlayerId); + return true; + } + + public override void Deserialize(MessageReader reader, bool initialState) + { + if (initialState) + { + this.isNew = reader.ReadBoolean(); + } + this.PlayerId = reader.ReadByte(); + } + + public void SetPlayerMaterialColors(Renderer rend) + { + GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(this.PlayerId); + PlayerControl.SetPlayerMaterialColors((int)((playerById != null) ? playerById.ColorId : 0), rend); + } + + public static void SetPlayerMaterialColors(int colorId, Renderer rend) + { + if (!rend) + { + return; + } + rend.material.SetColor("_BackColor", Palette.ShadowColors[colorId]); + rend.material.SetColor("_BodyColor", Palette.PlayerColors[colorId]); + rend.material.SetColor("_VisorColor", Palette.VisorColor); + } + + public void RpcSetScanner(bool value) + { + byte b = this.scannerCount + 1; + this.scannerCount = b; + byte b2 = b; + if (AmongUsClient.Instance.AmClient) + { + this.SetScanner(value, b2); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 16, SendOption.Reliable); + messageWriter.Write(value); + messageWriter.Write(b2); + messageWriter.EndMessage(); + } + + public void RpcPlayAnimation(byte animType) + { + if (AmongUsClient.Instance.AmClient) + { + this.PlayAnimation(animType); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 0, SendOption.None); + messageWriter.Write(animType); + messageWriter.EndMessage(); + } + + public void RpcSetStartCounter(int secondsLeft) + { + int lastStartCounter = this.LastStartCounter; + this.LastStartCounter = lastStartCounter + 1; + int value = lastStartCounter; + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 19, SendOption.Reliable); + messageWriter.WritePacked(value); + messageWriter.Write((sbyte)secondsLeft); + messageWriter.EndMessage(); + } + + public void RpcCompleteTask(uint idx) + { + if (AmongUsClient.Instance.AmClient) + { + this.CompleteTask(idx); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 1, SendOption.Reliable); + messageWriter.WritePacked(idx); + messageWriter.EndMessage(); + } + + public void RpcSyncSettings(GameOptionsData gameOptions) + { + if (!AmongUsClient.Instance.AmHost || DestroyableSingleton<TutorialManager>.InstanceExists) + { + return; + } + PlayerControl.GameOptions = gameOptions; + SaveManager.GameHostOptions = gameOptions; + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 2, SendOption.Reliable); + messageWriter.WriteBytesAndSize(gameOptions.ToBytes()); + messageWriter.EndMessage(); + } + + public void RpcSetInfected(GameData.PlayerInfo[] infected) + { + byte[] array = (from p in infected + select p.PlayerId).ToArray<byte>(); + if (AmongUsClient.Instance.AmClient) + { + this.SetInfected(array); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 3, SendOption.Reliable); + messageWriter.WriteBytesAndSize(array); + messageWriter.EndMessage(); + } + + public void CmdCheckName(string name) + { + if (AmongUsClient.Instance.AmHost) + { + this.CheckName(name); + return; + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 5, SendOption.Reliable, AmongUsClient.Instance.HostId); + messageWriter.Write(name); + AmongUsClient.Instance.FinishRpcImmediately(messageWriter); + } + + public void RpcSetSkin(uint skinId) + { + if (AmongUsClient.Instance.AmClient) + { + this.SetSkin(skinId); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 10, SendOption.Reliable); + messageWriter.WritePacked(skinId); + messageWriter.EndMessage(); + } + + public void RpcSetHat(uint hatId) + { + if (AmongUsClient.Instance.AmClient) + { + this.SetHat(hatId); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 9, SendOption.Reliable); + messageWriter.WritePacked(hatId); + messageWriter.EndMessage(); + } + + public void RpcSetPet(uint petId) + { + if (AmongUsClient.Instance.AmClient) + { + this.SetPet(petId); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 18, SendOption.Reliable); + messageWriter.WritePacked(petId); + messageWriter.EndMessage(); + } + + public void RpcSetName(string name) + { + if (AmongUsClient.Instance.AmClient) + { + this.SetName(name); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 6, SendOption.Reliable); + messageWriter.Write(name); + messageWriter.EndMessage(); + } + + public void CmdCheckColor(byte bodyColor) + { + if (AmongUsClient.Instance.AmHost) + { + this.CheckColor(bodyColor); + return; + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 7, SendOption.Reliable, AmongUsClient.Instance.HostId); + messageWriter.Write(bodyColor); + AmongUsClient.Instance.FinishRpcImmediately(messageWriter); + } + + public void RpcSetColor(byte bodyColor) + { + if (AmongUsClient.Instance.AmClient) + { + this.SetColor(bodyColor); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 8, SendOption.Reliable); + messageWriter.Write(bodyColor); + messageWriter.EndMessage(); + } + + public void RpcSetTimesImpostor(float percImpostor) + { + if (AmongUsClient.Instance.AmClient) + { + this.crewStreak = percImpostor; + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 14, SendOption.None); + messageWriter.Write(percImpostor); + messageWriter.EndMessage(); + } + + public bool RpcSendChat(string chatText) + { + if (string.IsNullOrWhiteSpace(chatText)) + { + return false; + } + if (AmongUsClient.Instance.AmClient && DestroyableSingleton<HudManager>.Instance) + { + DestroyableSingleton<HudManager>.Instance.Chat.AddChat(this, chatText); + } + if (chatText.IndexOf("who", StringComparison.OrdinalIgnoreCase) >= 0) + { + DestroyableSingleton<Telemetry>.Instance.SendWho(); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 13, SendOption.Reliable); + messageWriter.Write(chatText); + messageWriter.EndMessage(); + return true; + } + + public void RpcSendChatNote(byte srcPlayerId, ChatNoteTypes noteType) + { + if (AmongUsClient.Instance.AmClient) + { + GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(srcPlayerId); + DestroyableSingleton<HudManager>.Instance.Chat.AddChatNote(playerById, noteType); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 17, SendOption.Reliable); + messageWriter.Write(srcPlayerId); + messageWriter.Write((byte)noteType); + messageWriter.EndMessage(); + } + + public void CmdReportDeadBody(GameData.PlayerInfo target) + { + if (AmongUsClient.Instance.AmHost) + { + this.ReportDeadBody(target); + return; + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpc(this.NetId, 11, SendOption.Reliable); + messageWriter.Write((target != null) ? target.PlayerId : byte.MaxValue); + messageWriter.EndMessage(); + } + + public void RpcStartMeeting(GameData.PlayerInfo info) + { + if (AmongUsClient.Instance.AmClient) + { + base.StartCoroutine(this.CoStartMeeting(info)); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 15, SendOption.Reliable, -1); + messageWriter.Write((info != null) ? info.PlayerId : byte.MaxValue); + AmongUsClient.Instance.FinishRpcImmediately(messageWriter); + } + + public void RpcMurderPlayer(PlayerControl target) + { + if (AmongUsClient.Instance.AmClient) + { + this.MurderPlayer(target); + } + MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(this.NetId, 12, SendOption.Reliable, -1); + messageWriter.WriteNetObject(target); + AmongUsClient.Instance.FinishRpcImmediately(messageWriter); + } + + public override void HandleRpc(byte callId, MessageReader reader) + { + switch (callId) + { + case 0: + this.PlayAnimation(reader.ReadByte()); + return; + case 1: + this.CompleteTask(reader.ReadPackedUInt32()); + return; + case 2: + PlayerControl.GameOptions = GameOptionsData.FromBytes(reader.ReadBytesAndSize()); + return; + case 3: + this.SetInfected(reader.ReadBytesAndSize()); + return; + case 4: + this.Exiled(); + return; + case 5: + this.CheckName(reader.ReadString()); + return; + case 6: + this.SetName(reader.ReadString()); + return; + case 7: + this.CheckColor(reader.ReadByte()); + return; + case 8: + this.SetColor(reader.ReadByte()); + return; + case 9: + this.SetHat(reader.ReadPackedUInt32()); + return; + case 10: + this.SetSkin(reader.ReadPackedUInt32()); + return; + case 11: + { + GameData.PlayerInfo playerById = GameData.Instance.GetPlayerById(reader.ReadByte()); + this.ReportDeadBody(playerById); + return; + } + case 12: + { + PlayerControl target = reader.ReadNetObject<PlayerControl>(); + this.MurderPlayer(target); + return; + } + case 13: + { + string chatText = reader.ReadString(); + if (DestroyableSingleton<HudManager>.Instance) + { + DestroyableSingleton<HudManager>.Instance.Chat.AddChat(this, chatText); + return; + } + break; + } + case 14: + this.crewStreak = reader.ReadSingle(); + return; + case 15: + { + GameData.PlayerInfo playerById2 = GameData.Instance.GetPlayerById(reader.ReadByte()); + base.StartCoroutine(this.CoStartMeeting(playerById2)); + return; + } + case 16: + this.SetScanner(reader.ReadBoolean(), reader.ReadByte()); + break; + case 17: + { + GameData.PlayerInfo playerById3 = GameData.Instance.GetPlayerById(reader.ReadByte()); + DestroyableSingleton<HudManager>.Instance.Chat.AddChatNote(playerById3, (ChatNoteTypes)reader.ReadByte()); + return; + } + case 18: + this.SetPet(reader.ReadPackedUInt32()); + return; + case 19: + { + int num = reader.ReadPackedInt32(); + sbyte startCounter = reader.ReadSByte(); + if (DestroyableSingleton<GameStartManager>.InstanceExists && this.LastStartCounter < num) + { + this.LastStartCounter = num; + DestroyableSingleton<GameStartManager>.Instance.SetStartCounter(startCounter); + return; + } + break; + } + default: + return; + } + } +} |