public static RandomRoadPostfix GetRoadPostfix(RandomRoadPostfix checkingPostfix, bool alwaysPick = false, int forcePick = -1)
        {
            RandomRoadPostfix returnPostfix = null;

            if (Instance().m_roadPostfixes != null && Instance().m_roadPostfixes.Length > 0)
            {
                List<RandomRoadPostfix> validPostfixes = new List<RandomRoadPostfix>();

                foreach (RandomRoadPostfix postfix in Instance().m_roadPostfixes)
                {
                    if (ValidRoadPostfix(postfix, checkingPostfix))
                    {
                        validPostfixes.Add(postfix);
                    }
                }

                if (validPostfixes.Count > 0)
                {
                    bool assignAPostfix = true;

                    if (!Instance().m_alwaysAssignPostfixes)
                    {
                        assignAPostfix = UnityEngine.Random.Range(0f, 1f) < 0.5f;
                    }

                    if (assignAPostfix || alwaysPick)
                    {
                        int postfixToPick = (int)Math.Round(UnityEngine.Random.Range(0f, validPostfixes.Count - 1));
                        postfixToPick = forcePick != -1 ? forcePick : postfixToPick;

                        returnPostfix = validPostfixes[postfixToPick];
                    }
                }
            }

            return returnPostfix;
        }
        private static bool ValidRoadPostfix(RandomRoadPostfix postfixToCheck, RandomRoadPostfix checkingPostfix)
        {
            bool valid = true;

            if (postfixToCheck.MinimumLanes > 0 && checkingPostfix.MinimumLanes <= postfixToCheck.MinimumLanes)
            {
                valid = false;
            }

            if (postfixToCheck.MaximumLanes > 0 && checkingPostfix.MaximumLanes > postfixToCheck.MaximumLanes)
            {
                valid = false;
            }

            if (postfixToCheck.NameHasToContain != null && postfixToCheck.NameHasToContain != "" && !checkingPostfix.NameHasToContain.Contains(postfixToCheck.NameHasToContain.ToLower()))
            {
                valid = false;
            }

            return valid;
        }
        public static string GenerateRandomRoadName(ushort netSegmentId)
        {
            string returnRoadName = null;

            if (netSegmentId != 0)
            {
                NetManager netManager = Singleton<NetManager>.instance;
                NetSegment netSegment = netManager.m_segments.m_buffer[(int)netSegmentId];
                NetSegment.Flags segmentFlags = netSegment.m_flags;

                if (segmentFlags.IsFlagSet(NetSegment.Flags.Created))
                {
                    int forwardLanes = 0, backwardLanes = 0, totalLanes = 0;
                    string roadName = netSegment.Info.name.ToLower();
                    RandomRoadPrefix selectedPrefix = null;
                    RandomRoadName selectedRoadName = null;
                    RandomRoadPostfix selectedPostfix = null;

                    netSegment.CountLanes(netSegmentId, NetInfo.LaneType.Vehicle | NetInfo.LaneType.PublicTransport | NetInfo.LaneType.TransportVehicle, VehicleInfo.VehicleType.All, ref forwardLanes, ref backwardLanes);
                    totalLanes = forwardLanes + backwardLanes;

                    Debug.Log(roadName);
                    Debug.Log(forwardLanes.ToString());
                    Debug.Log(backwardLanes.ToString());

                    RandomRoadPrefix checkingPrefix = new RandomRoadPrefix()
                    {
                        NameHasToContain = roadName,
                        MinimumLanes = totalLanes,
                        MaximumLanes = totalLanes
                    };

                    RandomRoadName checkingName = new RandomRoadName()
                    {
                        NameHasToContain = roadName,
                        MinimumLanes = totalLanes,
                        MaximumLanes = totalLanes
                    };

                    RandomRoadPostfix checkingPostfix = new RandomRoadPostfix()
                    {
                        NameHasToContain = roadName,
                        MinimumLanes = totalLanes,
                        MaximumLanes = totalLanes
                    };

                    selectedRoadName = RandomNameUtility.GetRoadName(checkingName);

                    if (selectedRoadName != null)
                    {
                        bool lowercaseInitial = false;
                        returnRoadName = "";

                        if (!selectedRoadName.NoPrefix)
                        {
                            selectedPrefix = RandomNameUtility.GetRoadPrefix(checkingPrefix, selectedRoadName.ForcePrefix);
                        }

                        if (!selectedRoadName.NoPostfix)
                        {
                            selectedPostfix = RandomNameUtility.GetRoadPostfix(checkingPostfix, selectedRoadName.ForcePostfix);
                        }

                        if(selectedPrefix != null)
                        {
                            returnRoadName += selectedPrefix.Name;
                            returnRoadName += selectedPrefix.SpaceBetweenName ? " " : "";
                            lowercaseInitial = selectedPrefix.LowercaseInitialOnName;
                        }

                        returnRoadName += lowercaseInitial ? selectedRoadName.Name.ToLower() : selectedRoadName.Name; //TODO: There might be an instance where we actually only want the initial to be lowercase. Needs improvement

                        if (selectedPostfix != null)
                        {
                            returnRoadName += selectedPostfix.SpaceBetweenName ? " " : "";
                            returnRoadName += selectedPostfix.Name;
                        }

                        returnRoadName = TranslateRoadName(netSegmentId, returnRoadName);
                    }
                }
            }

            return returnRoadName;
        }