502 lines
12 KiB
Plaintext
502 lines
12 KiB
Plaintext
根据向量相似度分析，与 'StatDef' 最相关的代码定义如下：
|
|
|
|
---
|
|
**文件路径 (精确匹配):** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\StatDef.txt`
|
|
|
|
```csharp
|
|
public class StatDef : Def
|
|
{
|
|
private static HashSet<StatDef> mutableStats;
|
|
|
|
public StatCategoryDef category;
|
|
|
|
public Type workerClass = typeof(StatWorker);
|
|
|
|
public string labelForFullStatList;
|
|
|
|
public bool forInformationOnly;
|
|
|
|
[MustTranslate]
|
|
private string offsetLabel;
|
|
|
|
public float hideAtValue = -2.1474836E+09f;
|
|
|
|
public bool alwaysHide;
|
|
|
|
public bool showNonAbstract = true;
|
|
|
|
public bool showIfUndefined = true;
|
|
|
|
public bool showOnPawns = true;
|
|
|
|
public bool showOnHumanlikes = true;
|
|
|
|
public bool showOnNonWildManHumanlikes = true;
|
|
|
|
public bool showOnAnimals = true;
|
|
|
|
public bool showOnMechanoids = true;
|
|
|
|
public bool showOnNonWorkTables = true;
|
|
|
|
public bool showOnEntities = true;
|
|
|
|
public bool showOnDrones = true;
|
|
|
|
public bool showOnNonPowerPlants = true;
|
|
|
|
public bool showOnDefaultValue = true;
|
|
|
|
public bool showOnUnhaulables = true;
|
|
|
|
public bool showOnUntradeables = true;
|
|
|
|
public List<string> showIfModsLoaded;
|
|
|
|
public List<string> showIfModsLoadedAny;
|
|
|
|
public List<HediffDef> showIfHediffsPresent;
|
|
|
|
public bool neverDisabled;
|
|
|
|
public bool showZeroBaseValue;
|
|
|
|
public bool showOnSlavesOnly;
|
|
|
|
public bool showOnPlayerMechanoids;
|
|
|
|
public DevelopmentalStage showDevelopmentalStageFilter = DevelopmentalStage.Baby | DevelopmentalStage.Child | DevelopmentalStage.Adult;
|
|
|
|
public bool hideInClassicMode;
|
|
|
|
public List<PawnKindDef> showOnPawnKind;
|
|
|
|
public bool overridesHideStats;
|
|
|
|
public int displayPriorityInCategory;
|
|
|
|
public ToStringNumberSense toStringNumberSense = ToStringNumberSense.Absolute;
|
|
|
|
public ToStringStyle toStringStyle;
|
|
|
|
private ToStringStyle? toStringStyleUnfinalized;
|
|
|
|
[MustTranslate]
|
|
public string formatString;
|
|
|
|
[MustTranslate]
|
|
public string formatStringUnfinalized;
|
|
|
|
public bool finalizeEquippedStatOffset = true;
|
|
|
|
[MustTranslate]
|
|
public string statFactorsExplanationHeader;
|
|
|
|
public float defaultBaseValue = 1f;
|
|
|
|
public List<SkillNeed> skillNeedOffsets;
|
|
|
|
public float noSkillOffset;
|
|
|
|
public List<PawnCapacityOffset> capacityOffsets;
|
|
|
|
public List<StatDef> statFactors;
|
|
|
|
public bool applyFactorsIfNegative = true;
|
|
|
|
public List<SkillNeed> skillNeedFactors;
|
|
|
|
public float noSkillFactor = 1f;
|
|
|
|
public List<PawnCapacityFactor> capacityFactors;
|
|
|
|
public SimpleCurve postProcessCurve;
|
|
|
|
public List<StatDef> postProcessStatFactors;
|
|
|
|
public float minValue = -9999999f;
|
|
|
|
public float maxValue = 9999999f;
|
|
|
|
public float valueIfMissing;
|
|
|
|
public bool roundValue;
|
|
|
|
public float roundToFiveOver = float.MaxValue;
|
|
|
|
public bool minifiedThingInherits;
|
|
|
|
public bool supressDisabledError;
|
|
|
|
public bool cacheable;
|
|
|
|
public bool displayMaxWhenAboveOrEqual;
|
|
|
|
public bool scenarioRandomizable;
|
|
|
|
public SkillDef disableIfSkillDisabled;
|
|
|
|
public List<StatPart> parts;
|
|
|
|
[Unsaved(false)]
|
|
private StatWorker workerInt;
|
|
|
|
[Unsaved(false)]
|
|
public bool immutable;
|
|
|
|
public StatWorker Worker
|
|
{
|
|
get
|
|
{
|
|
if (workerInt == null)
|
|
{
|
|
if (parts != null)
|
|
{
|
|
for (int i = 0; i < parts.Count; i++)
|
|
{
|
|
parts[i].parentStat = this;
|
|
}
|
|
}
|
|
workerInt = (StatWorker)Activator.CreateInstance(workerClass);
|
|
workerInt.InitSetStat(this);
|
|
}
|
|
return workerInt;
|
|
}
|
|
}
|
|
|
|
public ToStringStyle ToStringStyleUnfinalized
|
|
{
|
|
get
|
|
{
|
|
if (!toStringStyleUnfinalized.HasValue)
|
|
{
|
|
return toStringStyle;
|
|
}
|
|
return toStringStyleUnfinalized.Value;
|
|
}
|
|
}
|
|
|
|
public string LabelForFullStatList
|
|
{
|
|
get
|
|
{
|
|
if (!labelForFullStatList.NullOrEmpty())
|
|
{
|
|
return labelForFullStatList;
|
|
}
|
|
return label;
|
|
}
|
|
}
|
|
|
|
public string LabelForFullStatListCap => LabelForFullStatList.CapitalizeFirst(this);
|
|
|
|
public string OffsetLabel => offsetLabel ?? label;
|
|
|
|
public string OffsetLabelCap => OffsetLabel.CapitalizeFirst();
|
|
|
|
public override IEnumerable<string> ConfigErrors()
|
|
{
|
|
foreach (string item in base.ConfigErrors())
|
|
{
|
|
yield return item;
|
|
}
|
|
if (capacityFactors != null)
|
|
{
|
|
foreach (PawnCapacityFactor capacityFactor in capacityFactors)
|
|
{
|
|
if (capacityFactor.weight > 1f)
|
|
{
|
|
yield return defName + " has activity factor with weight > 1";
|
|
}
|
|
}
|
|
}
|
|
if (parts == null)
|
|
{
|
|
yield break;
|
|
}
|
|
for (int i = 0; i < parts.Count; i++)
|
|
{
|
|
foreach (string item2 in parts[i].ConfigErrors())
|
|
{
|
|
yield return defName + " has error in StatPart " + parts[i].ToString() + ": " + item2;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string ValueToString(float val, ToStringNumberSense numberSense = ToStringNumberSense.Absolute, bool finalized = true)
|
|
{
|
|
return Worker.ValueToString(val, finalized, numberSense);
|
|
}
|
|
|
|
public static StatDef Named(string defName)
|
|
{
|
|
return DefDatabase<StatDef>.GetNamed(defName);
|
|
}
|
|
|
|
public override void PostLoad()
|
|
{
|
|
base.PostLoad();
|
|
if (parts != null)
|
|
{
|
|
List<StatPart> partsCopy = parts.ToList();
|
|
parts.SortBy((StatPart x) => 0f - x.priority, (StatPart x) => partsCopy.IndexOf(x));
|
|
}
|
|
}
|
|
|
|
public T GetStatPart<T>() where T : StatPart
|
|
{
|
|
return parts.OfType<T>().FirstOrDefault();
|
|
}
|
|
|
|
public bool CanShowWithLoadedMods()
|
|
{
|
|
if (!showIfModsLoaded.NullOrEmpty())
|
|
{
|
|
for (int i = 0; i < showIfModsLoaded.Count; i++)
|
|
{
|
|
if (!ModsConfig.IsActive(showIfModsLoaded[i]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (!showIfModsLoadedAny.NullOrEmpty())
|
|
{
|
|
bool result = false;
|
|
for (int j = 0; j < showIfModsLoadedAny.Count; j++)
|
|
{
|
|
if (ModsConfig.IsActive(showIfModsLoadedAny[j]))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static void PopulateMutableStats()
|
|
{
|
|
mutableStats = new HashSet<StatDef>();
|
|
foreach (TraitDef item in DefDatabase<TraitDef>.AllDefsListForReading)
|
|
{
|
|
foreach (TraitDegreeData degreeData in item.degreeDatas)
|
|
{
|
|
AddStatsFromModifiers(degreeData.statOffsets);
|
|
AddStatsFromModifiers(degreeData.statFactors);
|
|
}
|
|
}
|
|
foreach (HediffDef item2 in DefDatabase<HediffDef>.AllDefsListForReading)
|
|
{
|
|
if (item2.stages == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (HediffStage stage in item2.stages)
|
|
{
|
|
AddStatsFromModifiers(stage.statOffsets);
|
|
AddStatsFromModifiers(stage.statFactors);
|
|
if (stage.statOffsetEffectMultiplier != null)
|
|
{
|
|
mutableStats.Add(stage.statOffsetEffectMultiplier);
|
|
}
|
|
if (stage.statFactorEffectMultiplier != null)
|
|
{
|
|
mutableStats.Add(stage.statFactorEffectMultiplier);
|
|
}
|
|
if (stage.capacityFactorEffectMultiplier != null)
|
|
{
|
|
mutableStats.Add(stage.capacityFactorEffectMultiplier);
|
|
}
|
|
}
|
|
}
|
|
foreach (PreceptDef item3 in DefDatabase<PreceptDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item3.statOffsets);
|
|
AddStatsFromModifiers(item3.statFactors);
|
|
if (item3.roleEffects != null)
|
|
{
|
|
foreach (RoleEffect roleEffect in item3.roleEffects)
|
|
{
|
|
if (roleEffect is RoleEffect_PawnStatOffset roleEffect_PawnStatOffset)
|
|
{
|
|
mutableStats.Add(roleEffect_PawnStatOffset.statDef);
|
|
}
|
|
if (roleEffect is RoleEffect_PawnStatFactor roleEffect_PawnStatFactor)
|
|
{
|
|
mutableStats.Add(roleEffect_PawnStatFactor.statDef);
|
|
}
|
|
}
|
|
}
|
|
if (item3.abilityStatFactors == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (AbilityStatModifiers abilityStatFactor in item3.abilityStatFactors)
|
|
{
|
|
AddStatsFromModifiers(abilityStatFactor.modifiers);
|
|
}
|
|
}
|
|
foreach (GeneDef item4 in DefDatabase<GeneDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item4.statOffsets);
|
|
AddStatsFromModifiers(item4.statFactors);
|
|
if (item4.conditionalStatAffecters == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (ConditionalStatAffecter conditionalStatAffecter in item4.conditionalStatAffecters)
|
|
{
|
|
AddStatsFromModifiers(conditionalStatAffecter.statOffsets);
|
|
AddStatsFromModifiers(conditionalStatAffecter.statFactors);
|
|
}
|
|
}
|
|
foreach (ThingDef item5 in DefDatabase<ThingDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item5.equippedStatOffsets);
|
|
if (!item5.HasAssignableCompFrom(typeof(CompFacility)))
|
|
{
|
|
continue;
|
|
}
|
|
CompProperties_Facility compProperties = item5.GetCompProperties<CompProperties_Facility>();
|
|
if (compProperties?.statOffsets != null)
|
|
{
|
|
AddStatsFromModifiers(compProperties.statOffsets);
|
|
}
|
|
if (!(compProperties is CompProperties_FacilityQualityBased compProperties_FacilityQualityBased))
|
|
{
|
|
continue;
|
|
}
|
|
foreach (StatDef key in compProperties_FacilityQualityBased.statOffsetsPerQuality.Keys)
|
|
{
|
|
mutableStats.Add(key);
|
|
}
|
|
}
|
|
foreach (WeaponTraitDef item6 in DefDatabase<WeaponTraitDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item6.equippedStatOffsets);
|
|
}
|
|
foreach (LifeStageDef item7 in DefDatabase<LifeStageDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item7.statFactors);
|
|
AddStatsFromModifiers(item7.statOffsets);
|
|
}
|
|
foreach (InspirationDef item8 in DefDatabase<InspirationDef>.AllDefsListForReading)
|
|
{
|
|
AddStatsFromModifiers(item8.statOffsets);
|
|
AddStatsFromModifiers(item8.statFactors);
|
|
}
|
|
static void AddStatsFromModifiers(List<StatModifier> mods)
|
|
{
|
|
if (mods != null)
|
|
{
|
|
mutableStats.AddRange(mods.Select((StatModifier mod) => mod.stat));
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsImmutable()
|
|
{
|
|
if (workerClass != typeof(StatWorker))
|
|
{
|
|
return false;
|
|
}
|
|
if (!skillNeedOffsets.NullOrEmpty() || !skillNeedFactors.NullOrEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
if (!capacityOffsets.NullOrEmpty() || !capacityFactors.NullOrEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
if (!statFactors.NullOrEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
if (!parts.NullOrEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
if (!postProcessStatFactors.NullOrEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
if (mutableStats.Contains(this))
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void SetImmutability()
|
|
{
|
|
PopulateMutableStats();
|
|
foreach (StatDef item in DefDatabase<StatDef>.AllDefsListForReading)
|
|
{
|
|
item.immutable = item.IsImmutable();
|
|
item.Worker.SetCacheability(item.immutable);
|
|
}
|
|
}
|
|
|
|
public static void ResetStaticData()
|
|
{
|
|
mutableStats = null;
|
|
foreach (StatDef item in DefDatabase<StatDef>.AllDefsListForReading)
|
|
{
|
|
item.immutable = false;
|
|
item.Worker.DeleteStatCache();
|
|
}
|
|
}
|
|
}
|
|
```
|
|
---
|
|
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\Core\Defs\Stats\Stats_Building_Special.xml`
|
|
**相似度:** 0.5742
|
|
|
|
```xml
|
|
<StatDef>
|
|
<defName>WorkToBuild</defName>
|
|
<label>work to build</label>
|
|
<description>The base amount of work it takes to build a structure, once all materials are gathered.\n\nThe work required to deconstruct the structure is also based on this.</description>
|
|
<category>Building</category>
|
|
<defaultBaseValue>1</defaultBaseValue>
|
|
<minValue>0</minValue>
|
|
<toStringStyle>WorkAmount</toStringStyle>
|
|
<roundToFiveOver>300</roundToFiveOver>
|
|
<showIfUndefined>false</showIfUndefined>
|
|
<scenarioRandomizable>true</scenarioRandomizable>
|
|
<displayPriorityInCategory>3101</displayPriorityInCategory>
|
|
</StatDef>
|
|
```
|
|
---
|
|
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\Royalty\Defs\Stats\Stats_Basics_Special.xml`
|
|
**相似度:** 0.5197
|
|
|
|
```xml
|
|
<StatDef>
|
|
<defName>MeditationPlantGrowthOffset</defName>
|
|
<label>meditation plant growth offset</label>
|
|
<description>An offset applied to the growth rate of plants, like anima grass, from meditation. This value can change based on the number of artificial buildings nearby.</description>
|
|
<category>Meditation</category>
|
|
<defaultBaseValue>0</defaultBaseValue>
|
|
<showIfUndefined>false</showIfUndefined>
|
|
<showZeroBaseValue>false</showZeroBaseValue>
|
|
<showOnDefaultValue>false</showOnDefaultValue>
|
|
<displayPriorityInCategory>4000</displayPriorityInCategory>
|
|
<toStringStyle>PercentZero</toStringStyle>
|
|
<parts>
|
|
<li Class="StatPart_ArtificialBuildingsNearbyOffset">
|
|
<radius>27.9</radius>
|
|
<curve>
|
|
<points>
|
|
<li>(0, 0.0)</li>
|
|
<li>(5, -0.08)</li>
|
|
<li>(10, -0.15)</li>
|
|
<li>(50, -0.3)</li>
|
|
</points>
|
|
</curve>
|
|
</li>
|
|
</parts>
|
|
</StatDef>
|
|
``` |