public static void ResolveCollisions()
        {
            var seenHashes   = new HashSet <ushort>();
            var defsToRehash = new List <Def>();

            foreach (Type current in GenDefDatabase.AllDefTypesWithDatabases())
            {
                var type              = typeof(DefDatabase <>).MakeGenericType(current);
                var property          = type.GetProperty("AllDefs");
                var getMethod         = property.GetGetMethod();
                var allDefsInDatabase = (IEnumerable)getMethod.Invoke(null, null);
                defsToRehash.Clear();
                foreach (Def def in allDefsInDatabase)
                {
                    if (seenHashes.Contains(def.shortHash))
                    {
                        defsToRehash.Add(def);
                    }
                    else
                    {
                        seenHashes.Add(def.shortHash);
                    }
                }
                defsToRehash.SortBy(d => d.defName);
                for (int i = 0; i < defsToRehash.Count; i++)
                {
                    var def = defsToRehash[i];
                    def.shortHash = 0;
                    InjectedDefHasher.GiveShortHasToDef(def);
                    Log.Message(def.defName + " " + def.shortHash);
                }
                seenHashes.Clear();
            }
        }
        private static void ChangeDefLabels()
        {
            // Go through every appropriate def that has a label
            var changeableDefTypes = GenDefDatabase.AllDefTypesWithDatabases().Where(t => ShouldChangeDefTypeLabel(t)).ToList();

            for (int i = 0; i < changeableDefTypes.Count; i++)
            {
                var curDefs = GenDefDatabase.GetAllDefsInDatabaseForDef(changeableDefTypes[i]).ToList();
                for (int j = 0; j < curDefs.Count; j++)
                {
                    var curDef = curDefs[j];
                    if (!curDef.label.NullOrEmpty())
                    {
                        // Update the def's label
                        AdjustLabel(ref curDef.label);

                        // If the def is a ThingDef...
                        if (curDef is ThingDef tDef)
                        {
                            // If the ThingDef is a stuff item
                            if (tDef.stuffProps is StuffProperties stuffProps)
                            {
                                // Update the stuff adjective if there is one
                                if (!stuffProps.stuffAdjective.NullOrEmpty())
                                {
                                    AdjustLabel(ref stuffProps.stuffAdjective);
                                }
                            }
                        }
                    }
                }
            }
        }
Beispiel #3
0
        private static IEnumerable <Def> EnumerateAllDefs()
        {
            bool fast = false;

            if (fast)
            {
                foreach (var mod in LoadedModManager.RunningModsListForReading)
                {
                    if (mod == null)
                    {
                        continue;
                    }

                    foreach (var def in mod.AllDefs)
                    {
                        yield return(def);
                    }
                }

                foreach (var def in LoadedModManager.PatchedDefsForReading)
                {
                    yield return(def);
                }
            }
            else
            {
                foreach (var type in GenDefDatabase.AllDefTypesWithDatabases())
                {
                    foreach (var def in (IEnumerable)GenGeneric.GetStaticPropertyOnGenericType(typeof(DefDatabase <>), type, "AllDefs"))
                    {
                        var finalDef = def as Def;
                        yield return(finalDef);
                    }
                }
            }
        }