Example #1
0
            public static void Postfix(GameStartManager __instance)
            {
                // Send version as soon as PlayerControl.LocalPlayer exists
                if (PlayerControl.LocalPlayer != null && !versionSent)
                {
                    versionSent = true;
                    Helpers.shareGameVersion();
                }

                // Host update with version handshake infos
                if (AmongUsClient.Instance.AmHost)
                {
                    bool   blockStart = false;
                    string message    = "";
                    foreach (InnerNet.ClientData client in AmongUsClient.Instance.allClients.ToArray())
                    {
                        if (client.Character == null)
                        {
                            continue;
                        }
                        var dummyComponent = client.Character.GetComponent <DummyBehaviour>();
                        if (dummyComponent != null && dummyComponent.enabled)
                        {
                            continue;
                        }
                        else if (!playerVersions.ContainsKey(client.Id))
                        {
                            blockStart = true;
                            message   += $"<color=#FF0000FF>{client.Character.Data.PlayerName}:  {ModTranslation.getString("errorNotInstalled")}\n</color>";
                        }
                        else
                        {
                            PlayerVersion PV   = playerVersions[client.Id];
                            int           diff = TheOtherRolesPlugin.Version.CompareTo(PV.version);
                            if (diff > 0)
                            {
                                message   += $"<color=#FF0000FF>{client.Character.Data.PlayerName}:  {ModTranslation.getString("errorOlderVersion")} (v{playerVersions[client.Id].version.ToString()})\n</color>";
                                blockStart = true;
                            }
                            else if (diff < 0)
                            {
                                message   += $"<color=#FF0000FF>{client.Character.Data.PlayerName}:  {ModTranslation.getString("errorNewerVersion")} (v{playerVersions[client.Id].version.ToString()})\n</color>";
                                blockStart = true;
                            }
                            else if (!PV.GuidMatches())     // version presumably matches, check if Guid matches
                            {
                                message   += $"<color=#FF0000FF>{client.Character.Data.PlayerName}:  {ModTranslation.getString("errorWrongVersion")} v{playerVersions[client.Id].version.ToString()} <size=30%>({PV.guid.ToString()})</size>\n</color>";
                                blockStart = true;
                            }
                        }
                    }
                    if (blockStart)
                    {
                        __instance.StartButton.color  = __instance.startLabelText.color = Palette.DisabledClear;
                        __instance.GameStartText.text = message;
                        __instance.GameStartText.transform.localPosition = __instance.StartButton.transform.localPosition + Vector3.up * 2;
                    }
                    else
                    {
                        __instance.StartButton.color = __instance.startLabelText.color = ((__instance.LastPlayerCount >= __instance.MinPlayers) ? Palette.EnabledColor : Palette.DisabledClear);
                        __instance.GameStartText.transform.localPosition = __instance.StartButton.transform.localPosition;
                    }
                }

                // Client update with handshake infos
                if (!AmongUsClient.Instance.AmHost)
                {
                    if (!playerVersions.ContainsKey(AmongUsClient.Instance.HostId) || TheOtherRolesPlugin.Version.CompareTo(playerVersions[AmongUsClient.Instance.HostId].version) != 0)
                    {
                        kickingTimer += Time.deltaTime;
                        if (kickingTimer > 10)
                        {
                            kickingTimer = 0;
                            AmongUsClient.Instance.ExitGame(DisconnectReasons.ExitGame);
                            SceneChanger.ChangeScene("MainMenu");
                        }

                        __instance.GameStartText.text = String.Format(ModTranslation.getString("errorHostNoVersion"), Math.Round(10 - kickingTimer));
                        __instance.GameStartText.transform.localPosition = __instance.StartButton.transform.localPosition + Vector3.up * 2;
                    }
                    else
                    {
                        __instance.GameStartText.transform.localPosition = __instance.StartButton.transform.localPosition;
                        if (__instance.startState != GameStartManager.StartingStates.Countdown)
                        {
                            __instance.GameStartText.text = String.Empty;
                        }
                    }
                }

                // Lobby code replacement
                __instance.GameRoomName.text = TheOtherRolesPlugin.StreamerMode.Value ? $"<color={TheOtherRolesPlugin.StreamerModeReplacementColor.Value}>{TheOtherRolesPlugin.StreamerModeReplacementText.Value}</color>" : lobbyCodeText;

                // Lobby timer
                if (!AmongUsClient.Instance.AmHost || !GameData.Instance)
                {
                    return;                                                       // Not host or no instance
                }
                if (update)
                {
                    currentText = __instance.PlayerCounter.text;
                }

                timer = Mathf.Max(0f, timer -= Time.deltaTime);
                int    minutes = (int)timer / 60;
                int    seconds = (int)timer % 60;
                string suffix  = $" ({minutes:00}:{seconds:00})";

                __instance.PlayerCounter.text = currentText + suffix;
                __instance.PlayerCounter.autoSizeTextContainer = true;
            }
        private Player PlayerFromFutbinData(string rawPlayerData, string futbinId, PlayerType playerType)
        {
            var player = new Player
            {
                CreatedBy    = "AutoBuyer.DbBuilder",
                ModifiedBy   = "AutoBuyer.DbBuilder",
                CreatedDate  = DateTime.Now,
                ModifiedDate = DateTime.Now
            };
            var version = new PlayerVersion
            {
                ThirdPartyId = futbinId,
                Type         = playerType,
                CreatedBy    = "AutoBuyer.DbBuilder",
                ModifiedBy   = "AutoBuyer.DbBuilder",
                CreatedDate  = DateTime.Now,
                ModifiedDate = DateTime.Now
            };


            const string ratingIdentifier   = "<div style=\"color:;\" class=\"pcdisplay-rat\">";
            const string positionIdentifier = "<div style=\"color:;\" class=\"pcdisplay-pos\">";
            const string nameIdentifier     = "<div class=\"hidden\" id=\"baseurl\" data-url=\"player/";

            var lines = rawPlayerData.Split('\n').ToList();

            bool hasRating   = false;
            bool hasPosition = false;
            bool hasName     = false;

            foreach (var line in lines)
            {
                var trimmed = line.Trim();

                if (!hasRating && trimmed.StartsWith(ratingIdentifier))
                {
                    var rating = Convert.ToInt32(trimmed.Substring(ratingIdentifier.Length, 2));

                    version.Rating = rating;
                    hasRating      = true;
                }
                else if (!hasPosition && trimmed.StartsWith(positionIdentifier))
                {
                    var length = trimmed.LastIndexOf('<') - positionIdentifier.Length;

                    version.Position = trimmed.Substring(positionIdentifier.Length, length);
                    hasPosition      = true;
                }
                else if (trimmed.StartsWith(nameIdentifier))
                {
                    var completeIdentifier = $"{nameIdentifier}{futbinId}/";
                    var length             = trimmed.LastIndexOf('"') - completeIdentifier.Length;

                    var name = trimmed.Substring(completeIdentifier.Length, length).Trim();

                    player.Name = name;
                    hasName     = true;
                }

                //Doing this because many pages have previous year's info and we don't want those to overwrite
                if (hasRating && hasPosition && hasName)
                {
                    break;
                }
            }

            var ratingTemp    = version.Rating;
            var alreadyExists = PlayerData.TryGetValue(player.Name, out ratingTemp);

            if (!alreadyExists)
            {
                PlayerData.Add(player.Name, version.Rating);
                player.Versions.Add(version);
            }

            return(player);
        }
Example #3
0
            public static bool Prefix(GameStartManager __instance)
            {
                // Block game start if not everyone has the same mod version
                bool continueStart = true;

                if (AmongUsClient.Instance.AmHost)
                {
                    foreach (InnerNet.ClientData client in AmongUsClient.Instance.allClients)
                    {
                        if (client.Character == null)
                        {
                            continue;
                        }
                        var dummyComponent = client.Character.GetComponent <DummyBehaviour>();
                        if (dummyComponent != null && dummyComponent.enabled)
                        {
                            continue;
                        }

                        if (!playerVersions.ContainsKey(client.Id))
                        {
                            continueStart = false;
                            break;
                        }

                        PlayerVersion PV   = playerVersions[client.Id];
                        int           diff = TheOtherRolesPlugin.Version.CompareTo(PV.version);
                        if (diff != 0 || !PV.GuidMatches())
                        {
                            continueStart = false;
                            break;
                        }
                    }

                    if (CustomOptionHolder.uselessOptions.getBool() && CustomOptionHolder.dynamicMap.getBool() && continueStart)
                    {
                        // 0 = Skeld
                        // 1 = Mira HQ
                        // 2 = Polus
                        // 3 = Dleks - deactivated
                        // 4 = Airship
                        List <byte> possibleMaps = new List <byte>();
                        if (CustomOptionHolder.dynamicMapEnableSkeld.getBool())
                        {
                            possibleMaps.Add(0);
                        }
                        if (CustomOptionHolder.dynamicMapEnableMira.getBool())
                        {
                            possibleMaps.Add(1);
                        }
                        if (CustomOptionHolder.dynamicMapEnablePolus.getBool())
                        {
                            possibleMaps.Add(2);
                        }
                        // if (CustomOptionHolder.dynamicMapEnableDleks.getBool())
                        //     possibleMaps.Add(3);
                        if (CustomOptionHolder.dynamicMapEnableAirShip.getBool())
                        {
                            possibleMaps.Add(4);
                        }
                        if (CustomOptionHolder.dynamicMapEnableSubmerged.getBool())
                        {
                            possibleMaps.Add(5);
                        }
                        byte chosenMapId = possibleMaps[TheOtherRoles.rnd.Next(possibleMaps.Count)];

                        MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.DynamicMapOption, Hazel.SendOption.Reliable, -1);
                        writer.Write(chosenMapId);
                        AmongUsClient.Instance.FinishRpcImmediately(writer);
                        RPCProcedure.dynamicMapOption(chosenMapId);
                    }
                }
                return(continueStart);
            }