Dev 2.2.0

.gitignore

@@ -10,3 +10,4 @@ FodyWeavers.xsd
 TOHE.sln
 .vscode/settings.json
 /token.env
+token.env

Modules/AntiBlackout.cs

@@ -100,7 +100,13 @@ private static void RevivePlayersAndSetDummyImp()
         if (CustomWinnerHolder.WinnerTeam != CustomWinner.Default) return;
 
         PlayerControl dummyImp = Main.AllAlivePlayerControls.FirstOrDefault(x => x.PlayerId != ExilePlayerId);
-        if (dummyImp == null) return;
+
+        if (dummyImp == null)
+        {
+            Logger.Warn("Cant find a alive dummy Imp, AntiBlackout may break?", "AntiBlackout.RevivePlayersAndSetDummyImp");
+            Logger.SendInGame("Cant find a alive dummy Imp, AntiBlackout may break?");
+            return;
+        }
 
         foreach (var seer in Main.AllPlayerControls)
         {
@@ -127,7 +133,25 @@ public static void RestoreIsDead(bool doSend = true, [CallerMemberName] string c
         }
         isDeadCache.Clear();
         IsCached = false;
-        if (doSend) SendGameData();
+        if (doSend)
+        {
+            SendGameData();
+            _ = new LateTask(() => RestoreIsDeadByExile(), 0.3f, "AntiBlackOut_RestoreIsDeadByExile"); 
+        }
+    }
+
+    private static void RestoreIsDeadByExile()
+    {
+        var sender = CustomRpcSender.Create("AntiBlackout RestoreIsDeadByExile", SendOption.Reliable);
+        foreach (var player in Main.AllPlayerControls)
+        {
+            if (player.Data.IsDead && !player.Data.Disconnected)
+            {
+                sender.AutoStartRpc(player.NetId, (byte)RpcCalls.Exiled);
+                sender.EndRpc();
+            }
+        }
+        sender.SendMessage();
     }
 
     public static void SendGameData([CallerMemberName] string callerMethodName = "")

Modules/BanManager.cs

@@ -80,15 +80,20 @@ public static string GetHashedPuid(this ClientData player)
     {
         if (player == null) return "";
         string puid = player.ProductUserId;
+        return GetHashedPuid(puid);
+    }
+    public static string GetHashedPuid(string puid)
+    {
         using SHA256 sha256 = SHA256.Create();
-        
+
         // get sha-256 hash
         byte[] sha256Bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(puid));
         string sha256Hash = BitConverter.ToString(sha256Bytes).Replace("-", "").ToLower();
 
         // pick front 5 and last 4
         return string.Concat(sha256Hash.AsSpan(0, 5), sha256Hash.AsSpan(sha256Hash.Length - 4));
     }
+
     public static void AddBanPlayer(ClientData player)
     {
         if (!AmongUsClient.Instance.AmHost || player == null) return;
@@ -225,9 +230,9 @@ public static bool CheckEACList(string code, string hashedPuid)
             var splitUser = user["friendcode"].ToString().Split('#')[0].ToLower().Trim();
 
             if ((!string.IsNullOrEmpty(splitCode) && (splitCode == splitUser))
-                || (user["hashPUID"].ToString().ToLower().Trim() == hashedPuid.ToLower().Trim()))
+                || !hashedPuid.IsNullOrWhiteSpace() && (user["hashPUID"].ToString().ToLower().Trim() == hashedPuid.ToLower().Trim()))
             {
-                Logger.Warn($"friendcode : {code}, hashedPUID : {hashedPuid} banned by EAC reason : {user["reason"]}", "CheckEACList");
+                Logger.Warn($"friendcode : {code}, hashedPUID : {hashedPuid} banned by EAC reason : {user["friendcode"]} {user["reason"]}", "CheckEACList");
                 return true;
             }
         }

Modules/CriticalErrorManager.cs

@@ -0,0 +1,172 @@
+using Hazel;
+using static TOHE.Translator;
+
+namespace TOHE.Modules;
+
+public static class CriticalErrorManager
+{
+    private static bool IsError = false;
+    private static bool ErrorFromRpc = false;
+    private static byte ModdedPlayerId = byte.MinValue;
+
+    public static void SetCreiticalError(string reason, bool whileLoading, string sourseError = "")
+    {
+        Logger.Fatal($"Error: {reason} - triggered critical error", "Anti-black");
+        IsError = true;
+
+        if (!whileLoading) return;
+
+        if (AmongUsClient.Instance.AmHost)
+        {
+            ChatUpdatePatch.DoBlockChat = true;
+            Main.OverrideWelcomeMsg = GetString("AntiBlackOutNotifyInLobby");
+        }
+        else
+        {
+            MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.AntiBlackout, SendOption.Reliable);
+            writer.Write(reason);
+            writer.Write(sourseError);
+            AmongUsClient.Instance.FinishRpcImmediately(writer);
+        }
+    }
+    public static void ReadRpc(PlayerControl player, MessageReader reader)
+    {
+        IsError = true;
+        ErrorFromRpc = true;
+        Logger.Fatal($"Modded client: {player?.Data?.PlayerName}({player.PlayerId}): triggered critical error: {reader.ReadString()}", "Anti-black");
+        Logger.Error($"Error: {reader.ReadString()}", "CriticalErrorManager");
+
+        ModdedPlayerId = player.PlayerId;
+        ChatUpdatePatch.DoBlockChat = true;
+        Main.OverrideWelcomeMsg = string.Format(GetString("RpcAntiBlackOutNotifyInLobby"), player?.Data?.PlayerName, GetString("EndWhenPlayerBug"));
+    }
+    public static void CheckEndGame()
+    {
+        if (!IsError) return;
+
+        if (AmongUsClient.Instance.AmHost)
+        {
+            if (ErrorFromRpc)
+            {
+                var player = ModdedPlayerId.GetPlayer();
+
+                if (GameStates.IsShip || !GameStates.IsLobby || GameStates.IsCoStartGame)
+                {
+                    if (Options.EndWhenPlayerBug.GetBool())
+                    {
+                        ChatUpdatePatch.DoBlockChat = true;
+                        Main.OverrideWelcomeMsg = string.Format(GetString("RpcAntiBlackOutNotifyInLobby"), player?.Data?.PlayerName, GetString("EndWhenPlayerBug"));
+
+                        Logger.SendInGame(string.Format(GetString("RpcAntiBlackOutEndGame"), player?.Data?.PlayerName));
+
+                        if (GameStates.IsInGame && !GameStates.IsCoStartGame)
+                        {
+                            CustomWinnerHolder.ResetAndSetWinner(CustomWinner.Error);
+                            GameManager.Instance.LogicFlow.CheckEndCriteria();
+                            RPC.ForceEndGame(CustomWinner.Error);
+                        }
+                        else
+                        {
+                            _ = new LateTask(() =>
+                            {
+                                CustomWinnerHolder.ResetAndSetWinner(CustomWinner.Error);
+                                GameManager.Instance.LogicFlow.CheckEndCriteria();
+                                RPC.ForceEndGame(CustomWinner.Error);
+                            }, 1.5f, "RPC Anti-Black End Game As Critical Error");
+                        }
+                    }
+                    else
+                    {
+                        Logger.SendInGame(string.Format(GetString("RpcAntiBlackOutIgnored"), player?.Data?.PlayerName));
+
+                        if (player != null)
+                        {
+                            if (GameStates.IsInGame && !GameStates.IsCoStartGame)
+                            {
+                                AmongUsClient.Instance.KickPlayer(player.GetClientId(), false);
+                                Logger.SendInGame(string.Format(GetString("RpcAntiBlackOutKicked"), player?.Data?.PlayerName));
+                            }
+                            else
+                            {
+                                _ = new LateTask(() =>
+                                {
+                                    if (player == null) return;
+                                    AmongUsClient.Instance.KickPlayer(player.GetClientId(), false);
+                                    Logger.SendInGame(string.Format(GetString("RpcAntiBlackOutKicked"), player?.Data?.PlayerName));
+                                }, 0.5f, "RPC Anti-Black Kicked As Critical Error");
+                            }
+
+                            ChatUpdatePatch.DoBlockChat = false;
+                        }
+                    }
+                }
+                else if (GameStartManager.Instance != null)
+                {
+                    // We imagine rpc is received when starting game in lobby, not fucked yet
+                    if (AmongUsClient.Instance.AmHost)
+                    {
+                        GameStartManager.Instance.ResetStartState();
+                        if (player != null)
+                        {
+                            AmongUsClient.Instance.KickPlayer(player.GetClientId(), false);
+                        }
+                    }
+                    Logger.SendInGame(string.Format(GetString("RpcAntiBlackOutKicked"), player?.Data?.PlayerName));
+                }
+                else
+                {
+                    Logger.SendInGame("[Critical Error] Your client is in a unknow state while receiving AntiBlackOut rpcs from others");
+                    Logger.Fatal($"Client is in a unknow state while receiving AntiBlackOut rpcs from others", "Anti-black");
+                }
+            }
+            else
+            {
+                Logger.SendInGame(GetString("AntiBlackOutLoggerSendInGame"));
+
+                if (GameStates.IsShip || !GameStates.IsLobby || GameStates.IsCoStartGame)
+                {
+                    _ = new LateTask(() =>
+                    {
+                        CustomWinnerHolder.ResetAndSetWinner(CustomWinner.Error);
+                        GameManager.Instance.LogicFlow.CheckEndCriteria();
+                        RPC.ForceEndGame(CustomWinner.Error);
+                    }, 0.5f, "Anti-Black End Game As Critical Error");
+                }
+                else if (GameStartManager.Instance != null)
+                {
+                    GameStartManager.Instance.ResetStartState();
+                    AmongUsClient.Instance.RemoveUnownedObjects();
+                    Logger.SendInGame(GetString("AntiBlackOutLoggerSendInGame"));
+                }
+                else
+                {
+                    Logger.SendInGame("Host in a unknow antiblack bugged state");
+                    Logger.Fatal($"Host in a unknow antiblack bugged state", "Anti-black");
+                }
+            }
+        }
+        else
+        {
+            if (Options.EndWhenPlayerBug.GetBool())
+            {
+                Logger.SendInGame(GetString("AntiBlackOutRequestHostToForceEnd"));
+            }
+            else
+            {
+                Logger.SendInGame(GetString("AntiBlackOutHostRejectForceEnd"));
+
+                _ = new LateTask(() =>
+                {
+                    if (AmongUsClient.Instance.AmConnected)
+                    {
+                        AmongUsClient.Instance.ExitGame(DisconnectReasons.Custom);
+                        Logger.Fatal($"Disconnected from the game due critical error", "Anti-black");
+                    }
+                }, 1.5f, "Anti-Black Exit Game Due Critical Error");
+            }
+        }
+        IsError = false;
+        ErrorFromRpc = false;
+        ModdedPlayerId = byte.MinValue;
+    }
+}

Modules/CustomRolesHelper.cs

@@ -48,6 +48,7 @@ public static RoleTypes GetDYRole(this CustomRoles role) // Role has a kill butt
 
     public static bool HasImpKillButton(this PlayerControl player, bool considerVanillaShift = false)
     {
+        /*
         if (player == null) return false;
         var customRole = player.GetCustomRole();
         bool ModSideHasKillButton = customRole.GetDYRole() == RoleTypes.Impostor || customRole.GetVNRole() is CustomRoles.Impostor or CustomRoles.Shapeshifter or CustomRoles.Phantom;
@@ -59,6 +60,14 @@ public static bool HasImpKillButton(this PlayerControl player, bool considerVani
                                          (OriginalRole.GetDYRole() is RoleTypes.Impostor or RoleTypes.Shapeshifter || OriginalRole.GetVNRole() is CustomRoles.Impostor or CustomRoles.Shapeshifter or CustomRoles.Phantom) : ModSideHasKillButton;
 
         return vanillaSideHasKillButton;
+        */
+
+        // Due to the fact that change role basis is widely used in mod
+        // this function now always uses current mod role to decide kill button access?
+
+        if (player == null) return false;
+        var customRole = player.GetCustomRole();
+        return customRole.GetDYRole() == RoleTypes.Impostor || customRole.GetVNRole() is CustomRoles.Impostor or CustomRoles.Shapeshifter or CustomRoles.Phantom;
     }
     //This is a overall check for vanilla clients to see if they are imp basis 
     public static bool IsGhostRole(this CustomRoles role)
@@ -150,6 +159,7 @@ public static bool IsAmneCrew(this PlayerControl target)
         return target.IsCrewVenter()
                 || target.GetCustomRole() is
                 CustomRoles.Sheriff or
+                CustomRoles.ChiefOfPolice or
                 CustomRoles.LazyGuy or
                 CustomRoles.SuperStar or
                 CustomRoles.Celebrity or
@@ -564,6 +574,8 @@ public static bool CheckAddonConfilct(CustomRoles role, PlayerControl pc, bool c
             case CustomRoles.Overclocked:
                 if (!pc.CanUseKillButton())
                     return false;
+                if (pc.Is(CustomRoles.Reverie))
+                    return false;
                 break;
 
             case CustomRoles.Lazy:
@@ -790,7 +802,8 @@ public static bool CheckAddonConfilct(CustomRoles role, PlayerControl pc, bool c
             case CustomRoles.Rascal:
                 if (pc.Is(CustomRoles.SuperStar)
                     || pc.Is(CustomRoles.NiceMini)
-                    || pc.Is(CustomRoles.Madmate))
+                    || pc.Is(CustomRoles.Madmate)
+                    || pc.Is(CustomRoles.ChiefOfPolice))
                     return false;
                 if (!pc.GetCustomRole().IsCrewmate())
                     return false;
@@ -1251,8 +1264,10 @@ var r when r.IsNA() => CountTypes.Apocalypse,
            CustomRoles.Glitch => CountTypes.Glitch,
            CustomRoles.Spiritcaller => CountTypes.Spiritcaller,
            CustomRoles.RuthlessRomantic => CountTypes.RuthlessRomantic,
+           CustomRoles.Shocker => CountTypes.Shocker,
            CustomRoles.SchrodingersCat => CountTypes.None,
            CustomRoles.Solsticer => CountTypes.None,
+           CustomRoles.Revenant => CountTypes.None,
            _ => role.IsImpostorTeam() ? CountTypes.Impostor : CountTypes.Crew,
 
            // CustomRoles.Phantom => CountTypes.OutOfGame,
@@ -1316,6 +1331,7 @@ var r when r.IsNA() => CountTypes.Apocalypse,
             CustomRoles.RuthlessRomantic => CustomWinner.RuthlessRomantic,
             CustomRoles.Mini => CustomWinner.NiceMini,
             CustomRoles.Doppelganger => CustomWinner.Doppelganger,
+            CustomRoles.Shocker => CustomWinner.Shocker,
             _ => throw new NotImplementedException()
 
         };
@@ -1355,6 +1371,7 @@ var r when r.IsNA() => CountTypes.Apocalypse,
             CountTypes.Spiritcaller => CustomRoles.Spiritcaller,
             CountTypes.Arsonist => CustomRoles.Arsonist,
             CountTypes.RuthlessRomantic => CustomRoles.RuthlessRomantic,
+            CountTypes.Shocker => CustomRoles.Shocker,
             _ => throw new NotImplementedException()
         };
     public static bool HasSubRole(this PlayerControl pc) => Main.PlayerStates[pc.PlayerId].SubRoles.Any();
@@ -1435,5 +1452,6 @@ public enum CountTypes
     Werewolf,
     Agitater,
     RuthlessRomantic,
-    Necromancer
+    Necromancer,
+    Shocker
 }

Modules/DelayNetworkedData.cs

@@ -65,7 +65,7 @@ private static void DelaySpawnPlayerInfo(InnerNetClient __instance, int clientId
 
             foreach (var player in batch)
             {
-                if (messageWriter.Length > 1600) break;
+                if (messageWriter.Length > 500) break;
                 if (player != null && player.ClientId != clientId && !player.Disconnected)
                 {
                     __instance.WriteSpawnMessage(player, player.OwnerId, player.SpawnFlags, messageWriter);

Modules/EAC.cs

@@ -459,8 +459,8 @@ public static bool RpcReportDeadBodyCheck(PlayerControl player, NetworkedPlayerI
         if (!GameStates.IsInGame)
         {
             WarnHost();
-            Report(player, "Report body out of game");
-            HandleCheat(player, "Report body out of game");
+            Report(player, "Report body out of game C");
+            HandleCheat(player, "Report body out of game C");
             Logger.Fatal($"玩家【{player.GetClientId()}:{player.GetRealName()}】非游戏内开会，已驳回", "EAC");
             return true;
         }

Modules/ExtendedPlayerControl.cs

@@ -23,6 +23,8 @@ public static void RpcSetCustomRole(this PlayerControl player, CustomRoles role)
         if (role < CustomRoles.NotAssigned)
         {
             Main.PlayerStates[player.PlayerId].SetMainRole(role);
+            //  player.GetRoleClass()?.OnAdd(player.PlayerId);
+            // Remember to manually add OnAdd if you are setting role mid game
         }
         else if (role >= CustomRoles.NotAssigned)   //500:NoSubRole 501~:SubRole 
         {
@@ -274,7 +276,7 @@ public static void RpcSetPetDesync(this PlayerControl player, string petId, Play
     public static void RpcExile(this PlayerControl player)
     {
         player.Exiled();
-        MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(player.NetId, (byte)RpcCalls.Exiled, SendOption.None, -1);
+        MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(player.NetId, (byte)RpcCalls.Exiled, SendOption.Reliable, -1);
         AmongUsClient.Instance.FinishRpcImmediately(writer);
     }
     public static void RpcExileDesync(this PlayerControl player, PlayerControl seer)
@@ -836,6 +838,12 @@ public static void RpcTeleport(this PlayerControl player, Vector2 position, bool
             netTransform.SetDirtyBit(uint.MaxValue);
         }
 
+        if (!AmongUsClient.Instance.AmHost && !netTransform.AmOwner)
+        {
+            Logger.Error($"Canceled RpcTeleport bcz I am not host and not the owner of {player.PlayerId}'s netTransform.", "RpcTeleport");
+            return;
+        }
+
         ushort newSid = (ushort)(netTransform.lastSequenceId + 8);
         MessageWriter messageWriter = AmongUsClient.Instance.StartRpcImmediately(netTransform.NetId, (byte)RpcCalls.SnapTo, SendOption.Reliable);
         NetHelpers.WriteVector2(position, messageWriter);