2691 lines
69 KiB
Plaintext
2691 lines
69 KiB
Plaintext
根据向量相似度分析，与 'Human, ThingDef' 最相关的代码定义如下：
|
|
|
|
---
|
|
**文件路径 (精确匹配):** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\Verse\ThingDef.txt`
|
|
|
|
```csharp
|
|
public class ThingDef : BuildableDef
|
|
{
|
|
public Type thingClass;
|
|
|
|
public ThingCategory category;
|
|
|
|
public TickerType tickerType;
|
|
|
|
public int stackLimit = 1;
|
|
|
|
public IntVec2 size = IntVec2.One;
|
|
|
|
public bool destroyable = true;
|
|
|
|
public bool rotatable = true;
|
|
|
|
public bool smallVolume;
|
|
|
|
public bool useHitPoints = true;
|
|
|
|
public bool receivesSignals;
|
|
|
|
public List<CompProperties> comps = new List<CompProperties>();
|
|
|
|
public List<ThingDef> virtualDefs = new List<ThingDef>();
|
|
|
|
public ThingDef virtualDefParent;
|
|
|
|
[NoTranslate]
|
|
public string devNote;
|
|
|
|
public List<ThingDefCountRangeClass> killedLeavingsRanges;
|
|
|
|
public List<ThingDefCountClass> killedLeavings;
|
|
|
|
public List<ThingDefCountClass> killedLeavingsPlayerHostile;
|
|
|
|
public float killedLeavingsChance = 1f;
|
|
|
|
public bool forceLeavingsAllowed;
|
|
|
|
public List<ThingDefCountClass> butcherProducts;
|
|
|
|
public List<ThingDefCountClass> smeltProducts;
|
|
|
|
public bool smeltable;
|
|
|
|
public bool burnableByRecipe;
|
|
|
|
public bool randomizeRotationOnSpawn;
|
|
|
|
public List<DamageMultiplier> damageMultipliers;
|
|
|
|
public bool isTechHediff;
|
|
|
|
public RecipeMakerProperties recipeMaker;
|
|
|
|
public ThingDef minifiedDef;
|
|
|
|
public bool isUnfinishedThing;
|
|
|
|
public bool leaveResourcesWhenKilled;
|
|
|
|
public ThingDef slagDef;
|
|
|
|
public bool isFrameInt;
|
|
|
|
public List<IntVec3> multipleInteractionCellOffsets;
|
|
|
|
public IntVec3 interactionCellOffset = IntVec3.Zero;
|
|
|
|
public bool hasInteractionCell;
|
|
|
|
public ThingDef interactionCellIcon;
|
|
|
|
public bool interactionCellIconReverse;
|
|
|
|
public ThingDef filthLeaving;
|
|
|
|
public bool forceDebugSpawnable;
|
|
|
|
public bool intricate;
|
|
|
|
public bool scatterableOnMapGen = true;
|
|
|
|
public float deepCommonality;
|
|
|
|
public int deepCountPerCell = 300;
|
|
|
|
public int deepCountPerPortion = -1;
|
|
|
|
public IntRange deepLumpSizeRange = IntRange.Zero;
|
|
|
|
public float generateCommonality = 1f;
|
|
|
|
public float generateAllowChance = 1f;
|
|
|
|
private bool canOverlapZones = true;
|
|
|
|
public FloatRange startingHpRange = FloatRange.One;
|
|
|
|
[NoTranslate]
|
|
public List<string> thingSetMakerTags;
|
|
|
|
public bool alwaysFlee;
|
|
|
|
public List<RecipeDef> recipes;
|
|
|
|
public bool messageOnDeteriorateInStorage = true;
|
|
|
|
public bool deteriorateFromEnvironmentalEffects = true;
|
|
|
|
public bool canDeteriorateUnspawned;
|
|
|
|
public bool canLoadIntoCaravan = true;
|
|
|
|
public bool isMechClusterThreat;
|
|
|
|
public FloatRange displayNumbersBetweenSameDefDistRange = FloatRange.Zero;
|
|
|
|
public int minRewardCount = 1;
|
|
|
|
public bool preventSkyfallersLandingOn;
|
|
|
|
public FactionDef requiresFactionToAcquire;
|
|
|
|
public float relicChance;
|
|
|
|
public OrderedTakeGroupDef orderedTakeGroup;
|
|
|
|
public int allowedArchonexusCount;
|
|
|
|
public int possessionCount;
|
|
|
|
public bool notifyMapRemoved;
|
|
|
|
public bool canScatterOver = true;
|
|
|
|
public bool genericMarketSellable = true;
|
|
|
|
public bool drawHighlight;
|
|
|
|
public Color? highlightColor;
|
|
|
|
public bool drawHighlightOnlyForHostile;
|
|
|
|
public bool autoTargetNearbyIdenticalThings;
|
|
|
|
public bool preventDroppingThingsOn;
|
|
|
|
public bool hiddenWhileUndiscovered;
|
|
|
|
public bool disableImpassableShotOverConfigError;
|
|
|
|
public bool showInSearch = true;
|
|
|
|
public bool bringAlongOnGravship = true;
|
|
|
|
public ThingDef dropPodFaller;
|
|
|
|
public bool preventSpawningInResourcePod;
|
|
|
|
public bool pathfinderDangerous;
|
|
|
|
public bool noRightClickDraftAttack;
|
|
|
|
public int gravshipSpawnPriority = 1;
|
|
|
|
public List<string> replaceTags;
|
|
|
|
public GraphicData graphicData;
|
|
|
|
public DrawerType drawerType = DrawerType.RealtimeOnly;
|
|
|
|
public bool drawOffscreen;
|
|
|
|
public ColorGenerator colorGenerator;
|
|
|
|
public float hideAtSnowOrSandDepth = 99999f;
|
|
|
|
public bool drawDamagedOverlay = true;
|
|
|
|
public bool castEdgeShadows;
|
|
|
|
public float staticSunShadowHeight;
|
|
|
|
public bool useSameGraphicForGhost;
|
|
|
|
public bool useBlueprintGraphicAsGhost;
|
|
|
|
public List<ThingStyleChance> randomStyle;
|
|
|
|
public float randomStyleChance;
|
|
|
|
public bool canEditAnyStyle;
|
|
|
|
public bool dontPrint;
|
|
|
|
public ThingDef defaultStuff;
|
|
|
|
public int killedLeavingsExpandRect;
|
|
|
|
public bool minifiedManualDraw;
|
|
|
|
public float minifiedDrawScale = 1f;
|
|
|
|
public Rot4 overrideMinifiedRot = Rot4.Invalid;
|
|
|
|
public Vector3 minifiedDrawOffset = Vector3.zero;
|
|
|
|
public float deselectedSelectionBracketFactor = 1f;
|
|
|
|
public bool selectable;
|
|
|
|
public bool containedPawnsSelectable;
|
|
|
|
public bool containedItemsSelectable;
|
|
|
|
public bool neverMultiSelect;
|
|
|
|
public bool isAutoAttackableMapObject;
|
|
|
|
public bool hasTooltip;
|
|
|
|
public List<Type> inspectorTabs;
|
|
|
|
[Unsaved(false)]
|
|
public List<InspectTabBase> inspectorTabsResolved;
|
|
|
|
public bool seeThroughFog;
|
|
|
|
public bool drawGUIOverlay;
|
|
|
|
public bool drawGUIOverlayQuality = true;
|
|
|
|
public ResourceCountPriority resourceReadoutPriority;
|
|
|
|
public bool resourceReadoutAlwaysShow;
|
|
|
|
public bool drawPlaceWorkersWhileSelected;
|
|
|
|
public bool drawPlaceWorkersWhileInstallBlueprintSelected;
|
|
|
|
public ConceptDef storedConceptLearnOpportunity;
|
|
|
|
public float uiIconScale = 1f;
|
|
|
|
public bool hasCustomRectForSelector;
|
|
|
|
public bool hideStats;
|
|
|
|
public bool hideInspect;
|
|
|
|
public bool onlyShowInspectString;
|
|
|
|
public bool hideMainDesc;
|
|
|
|
public bool alwaysHaulable;
|
|
|
|
public bool designateHaulable;
|
|
|
|
public List<ThingCategoryDef> thingCategories;
|
|
|
|
public bool mineable;
|
|
|
|
public bool socialPropernessMatters;
|
|
|
|
public bool stealable = true;
|
|
|
|
public SoundDef soundSpawned;
|
|
|
|
public SoundDef soundDrop;
|
|
|
|
public SoundDef soundPickup;
|
|
|
|
public SoundDef soundInteract;
|
|
|
|
public SoundDef soundImpactDefault;
|
|
|
|
public SoundDef soundPlayInstrument;
|
|
|
|
public SoundDef soundOpen;
|
|
|
|
public bool saveCompressible;
|
|
|
|
public bool isSaveable = true;
|
|
|
|
public bool holdsRoof;
|
|
|
|
public float fillPercent;
|
|
|
|
public bool coversFloor;
|
|
|
|
public bool neverOverlapFloors;
|
|
|
|
public SurfaceType surfaceType;
|
|
|
|
public bool wipesPlants;
|
|
|
|
public bool blockPlants;
|
|
|
|
public bool blockLight;
|
|
|
|
public bool blockWind;
|
|
|
|
public bool blockWeather;
|
|
|
|
public Tradeability tradeability = Tradeability.All;
|
|
|
|
[NoTranslate]
|
|
public List<string> tradeTags;
|
|
|
|
public bool tradeNeverStack;
|
|
|
|
public bool tradeNeverGenerateStacked;
|
|
|
|
public bool healthAffectsPrice = true;
|
|
|
|
public ColorGenerator colorGeneratorInTraderStock;
|
|
|
|
private List<VerbProperties> verbs;
|
|
|
|
public List<Tool> tools;
|
|
|
|
public float equippedAngleOffset;
|
|
|
|
public float equippedDistanceOffset;
|
|
|
|
public EquipmentType equipmentType;
|
|
|
|
public TechLevel techLevel;
|
|
|
|
public List<WeaponClassDef> weaponClasses;
|
|
|
|
[NoTranslate]
|
|
public List<string> weaponTags;
|
|
|
|
[NoTranslate]
|
|
public List<string> techHediffsTags;
|
|
|
|
public bool violentTechHediff;
|
|
|
|
public bool destroyOnDrop;
|
|
|
|
public List<StatModifier> equippedStatOffsets;
|
|
|
|
public SoundDef meleeHitSound;
|
|
|
|
public float recoilPower = 1f;
|
|
|
|
public float recoilRelaxation = 10f;
|
|
|
|
public bool rotateInShelves = true;
|
|
|
|
public bool mergeVerbGizmos = true;
|
|
|
|
public BuildableDef entityDefToBuild;
|
|
|
|
public ThingDef projectileWhenLoaded;
|
|
|
|
public RulePackDef ideoBuildingNamerBase;
|
|
|
|
public EntityCodexEntryDef entityCodexEntry;
|
|
|
|
public IngestibleProperties ingestible;
|
|
|
|
public FilthProperties filth;
|
|
|
|
public GasProperties gas;
|
|
|
|
public BuildingProperties building;
|
|
|
|
public RaceProperties race;
|
|
|
|
public ApparelProperties apparel;
|
|
|
|
public MoteProperties mote;
|
|
|
|
public PlantProperties plant;
|
|
|
|
public ProjectileProperties projectile;
|
|
|
|
public StuffProperties stuffProps;
|
|
|
|
public SkyfallerProperties skyfaller;
|
|
|
|
public PawnFlyerProperties pawnFlyer;
|
|
|
|
public RitualFocusProperties ritualFocus;
|
|
|
|
public IngredientProperties ingredient;
|
|
|
|
public MapPortalProperties portal;
|
|
|
|
public bool canBeUsedUnderRoof = true;
|
|
|
|
[Unsaved(false)]
|
|
private string descriptionDetailedCached;
|
|
|
|
[Unsaved(false)]
|
|
public Graphic interactionCellGraphic;
|
|
|
|
[Unsaved(false)]
|
|
private bool? isNaturalOrganCached;
|
|
|
|
[Unsaved(false)]
|
|
private bool? hasSunShadowsCached;
|
|
|
|
[Unsaved(false)]
|
|
private List<StyleCategoryDef> cachedRelevantStyleCategories;
|
|
|
|
public const int SmallUnitPerVolume = 10;
|
|
|
|
public const float SmallVolumePerUnit = 0.1f;
|
|
|
|
public const float ArchonexusMaxItemStackMass = 5f;
|
|
|
|
public const int ArchonexusMaxItemStackCount = 25;
|
|
|
|
public const float ArchonexusMaxItemStackValue = 2000f;
|
|
|
|
public const int ArchonexusAutoCalculateValue = -1;
|
|
|
|
private List<RecipeDef> allRecipesCached;
|
|
|
|
private static List<VerbProperties> EmptyVerbPropertiesList = new List<VerbProperties>();
|
|
|
|
private Dictionary<ThingDef, Thing> concreteExamplesInt;
|
|
|
|
public bool EverHaulable
|
|
{
|
|
get
|
|
{
|
|
if (!alwaysHaulable)
|
|
{
|
|
return designateHaulable;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool EverPollutable => !building.isNaturalRock;
|
|
|
|
public float VolumePerUnit
|
|
{
|
|
get
|
|
{
|
|
if (smallVolume)
|
|
{
|
|
return 0.1f;
|
|
}
|
|
return 1f;
|
|
}
|
|
}
|
|
|
|
public override IntVec2 Size => size;
|
|
|
|
public bool DiscardOnDestroyed => race == null;
|
|
|
|
public int BaseMaxHitPoints => Mathf.RoundToInt(this.GetStatValueAbstract(StatDefOf.MaxHitPoints));
|
|
|
|
public float BaseFlammability => this.GetStatValueAbstract(StatDefOf.Flammability);
|
|
|
|
public float BaseMarketValue
|
|
{
|
|
get
|
|
{
|
|
return this.GetStatValueAbstract(StatDefOf.MarketValue);
|
|
}
|
|
set
|
|
{
|
|
this.SetStatBaseValue(StatDefOf.MarketValue, value);
|
|
}
|
|
}
|
|
|
|
public float BaseMass => this.GetStatValueAbstract(StatDefOf.Mass);
|
|
|
|
public int ArchonexusMaxAllowedCount
|
|
{
|
|
get
|
|
{
|
|
if (allowedArchonexusCount == -1)
|
|
{
|
|
return Mathf.Min(stackLimit, 25, (BaseMass > 0f) ? ((int)(5f / BaseMass)) : 0, (BaseMarketValue > 0f) ? ((int)(2000f / BaseMarketValue)) : 0);
|
|
}
|
|
return allowedArchonexusCount;
|
|
}
|
|
}
|
|
|
|
public bool PlayerAcquirable
|
|
{
|
|
get
|
|
{
|
|
if (destroyOnDrop)
|
|
{
|
|
return false;
|
|
}
|
|
if (this == ThingDefOf.ReinforcedBarrel && Find.Storyteller != null && Find.Storyteller.difficulty.classicMortars)
|
|
{
|
|
return false;
|
|
}
|
|
if (requiresFactionToAcquire != null && Find.World != null && Find.World.factionManager != null)
|
|
{
|
|
return Find.FactionManager.FirstFactionOfDef(requiresFactionToAcquire) != null;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool EverTransmitsPower
|
|
{
|
|
get
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i] is CompProperties_Power { transmitsPower: not false })
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool Minifiable => minifiedDef != null;
|
|
|
|
public bool HasThingIDNumber => category != ThingCategory.Mote;
|
|
|
|
public List<RecipeDef> AllRecipes
|
|
{
|
|
get
|
|
{
|
|
if (allRecipesCached == null)
|
|
{
|
|
allRecipesCached = new List<RecipeDef>();
|
|
if (recipes != null)
|
|
{
|
|
for (int i = 0; i < recipes.Count; i++)
|
|
{
|
|
allRecipesCached.Add(recipes[i]);
|
|
}
|
|
}
|
|
List<RecipeDef> allDefsListForReading = DefDatabase<RecipeDef>.AllDefsListForReading;
|
|
for (int j = 0; j < allDefsListForReading.Count; j++)
|
|
{
|
|
if (allDefsListForReading[j].recipeUsers != null && allDefsListForReading[j].recipeUsers.Contains(this))
|
|
{
|
|
allRecipesCached.Add(allDefsListForReading[j]);
|
|
}
|
|
}
|
|
}
|
|
return allRecipesCached;
|
|
}
|
|
}
|
|
|
|
public bool ConnectToPower
|
|
{
|
|
get
|
|
{
|
|
if (EverTransmitsPower)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i].compClass == typeof(CompPowerBattery))
|
|
{
|
|
return true;
|
|
}
|
|
if (comps[i].compClass == typeof(CompPowerTrader))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool CoexistsWithFloors
|
|
{
|
|
get
|
|
{
|
|
if (!neverOverlapFloors)
|
|
{
|
|
return !coversFloor;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public FillCategory Fillage
|
|
{
|
|
get
|
|
{
|
|
if (fillPercent < 0.01f)
|
|
{
|
|
return FillCategory.None;
|
|
}
|
|
if (fillPercent > 0.99f)
|
|
{
|
|
return FillCategory.Full;
|
|
}
|
|
return FillCategory.Partial;
|
|
}
|
|
}
|
|
|
|
public bool MakeFog => Fillage == FillCategory.Full;
|
|
|
|
public bool CanOverlapZones
|
|
{
|
|
get
|
|
{
|
|
if (building != null && building.SupportsPlants)
|
|
{
|
|
return false;
|
|
}
|
|
if (passability == Traversability.Impassable && category != ThingCategory.Plant && !HasComp(typeof(CompTransporter)))
|
|
{
|
|
return false;
|
|
}
|
|
if ((int)surfaceType >= 1)
|
|
{
|
|
return false;
|
|
}
|
|
if (typeof(ISlotGroupParent).IsAssignableFrom(thingClass))
|
|
{
|
|
return false;
|
|
}
|
|
if (!canOverlapZones)
|
|
{
|
|
return false;
|
|
}
|
|
if ((IsBlueprint || IsFrame) && entityDefToBuild is ThingDef thingDef)
|
|
{
|
|
return thingDef.CanOverlapZones;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool CountAsResource => resourceReadoutPriority != ResourceCountPriority.Uncounted;
|
|
|
|
public List<VerbProperties> Verbs
|
|
{
|
|
get
|
|
{
|
|
if (verbs != null)
|
|
{
|
|
return verbs;
|
|
}
|
|
return EmptyVerbPropertiesList;
|
|
}
|
|
}
|
|
|
|
public bool CanHaveFaction
|
|
{
|
|
get
|
|
{
|
|
if (IsBlueprint || IsFrame)
|
|
{
|
|
return true;
|
|
}
|
|
return category switch
|
|
{
|
|
ThingCategory.Pawn => true,
|
|
ThingCategory.Building => true,
|
|
_ => false,
|
|
};
|
|
}
|
|
}
|
|
|
|
public bool Claimable
|
|
{
|
|
get
|
|
{
|
|
if (building != null && building.claimable)
|
|
{
|
|
return !building.isNaturalRock;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public ThingCategoryDef FirstThingCategory
|
|
{
|
|
get
|
|
{
|
|
if (thingCategories.NullOrEmpty())
|
|
{
|
|
return null;
|
|
}
|
|
return thingCategories[0];
|
|
}
|
|
}
|
|
|
|
public float MedicineTendXpGainFactor => Mathf.Clamp(this.GetStatValueAbstract(StatDefOf.MedicalPotency) * 0.7f, 0.5f, 1f);
|
|
|
|
public bool CanEverDeteriorate
|
|
{
|
|
get
|
|
{
|
|
if (!useHitPoints)
|
|
{
|
|
return false;
|
|
}
|
|
if (category != ThingCategory.Item)
|
|
{
|
|
if (plant != null)
|
|
{
|
|
return plant.canDeteriorate;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool CanInteractThroughCorners
|
|
{
|
|
get
|
|
{
|
|
if (category != ThingCategory.Building)
|
|
{
|
|
return false;
|
|
}
|
|
if (!holdsRoof)
|
|
{
|
|
return false;
|
|
}
|
|
if (building != null && building.isNaturalRock && !IsSmoothed)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool AffectsRegions
|
|
{
|
|
get
|
|
{
|
|
if (passability != Traversability.Impassable && !IsDoor)
|
|
{
|
|
return IsFence;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool AffectsReachability
|
|
{
|
|
get
|
|
{
|
|
if (AffectsRegions)
|
|
{
|
|
return true;
|
|
}
|
|
if (passability == Traversability.Impassable || IsDoor)
|
|
{
|
|
return true;
|
|
}
|
|
if (TouchPathEndModeUtility.MakesOccupiedCellsAlwaysReachableDiagonally(this))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public string DescriptionDetailed
|
|
{
|
|
get
|
|
{
|
|
if (descriptionDetailedCached == null)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append(description);
|
|
if (IsApparel)
|
|
{
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine(string.Format("{0}: {1}", "Layer".Translate(), apparel.GetLayersString()));
|
|
stringBuilder.Append(string.Format("{0}: {1}", "Covers".Translate(), apparel.GetCoveredOuterPartsString(BodyDefOf.Human)));
|
|
if (equippedStatOffsets != null && equippedStatOffsets.Count > 0)
|
|
{
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine();
|
|
for (int i = 0; i < equippedStatOffsets.Count; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
stringBuilder.AppendLine();
|
|
}
|
|
StatModifier statModifier = equippedStatOffsets[i];
|
|
stringBuilder.Append($"{statModifier.stat.LabelCap}: {statModifier.ValueToStringAsOffset}");
|
|
}
|
|
}
|
|
}
|
|
descriptionDetailedCached = stringBuilder.ToString();
|
|
}
|
|
return descriptionDetailedCached;
|
|
}
|
|
}
|
|
|
|
public bool CanBenefitFromCover
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Pawn)
|
|
{
|
|
return true;
|
|
}
|
|
if (building != null && building.IsTurret)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool PotentiallySmeltable
|
|
{
|
|
get
|
|
{
|
|
if (!smeltable)
|
|
{
|
|
return false;
|
|
}
|
|
if (base.MadeFromStuff)
|
|
{
|
|
foreach (ThingDef item in GenStuff.AllowedStuffsFor(this))
|
|
{
|
|
if (item.smeltable)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool HasSingleOrMultipleInteractionCells
|
|
{
|
|
get
|
|
{
|
|
if (!hasInteractionCell)
|
|
{
|
|
return !multipleInteractionCellOffsets.NullOrEmpty();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool IsApparel => apparel != null;
|
|
|
|
public bool IsBed => typeof(Building_Bed).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsWall
|
|
{
|
|
get
|
|
{
|
|
if (building != null)
|
|
{
|
|
return building.isWall;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsCorpse => typeof(Corpse).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsFrame => isFrameInt;
|
|
|
|
public bool IsBlueprint
|
|
{
|
|
get
|
|
{
|
|
if (entityDefToBuild != null)
|
|
{
|
|
return category == ThingCategory.Ethereal;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsStuff => stuffProps != null;
|
|
|
|
public bool IsMedicine => statBases.StatListContains(StatDefOf.MedicalPotency);
|
|
|
|
public bool IsDoor => typeof(Building_Door).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsFence
|
|
{
|
|
get
|
|
{
|
|
if (building != null)
|
|
{
|
|
return building.isFence;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsFilth => filth != null;
|
|
|
|
public bool IsIngestible => ingestible != null;
|
|
|
|
public bool IsNutritionGivingIngestible
|
|
{
|
|
get
|
|
{
|
|
if (IsIngestible)
|
|
{
|
|
return ingestible.CachedNutrition > 0f;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsNutritionGivingIngestibleForHumanlikeBabies
|
|
{
|
|
get
|
|
{
|
|
if (IsNutritionGivingIngestible && ingestible.HumanEdible)
|
|
{
|
|
return ingestible.babiesCanIngest;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsWeapon
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Item && (!verbs.NullOrEmpty() || !tools.NullOrEmpty()))
|
|
{
|
|
return !IsApparel;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsCommsConsole => typeof(Building_CommsConsole).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsOrbitalTradeBeacon => typeof(Building_OrbitalTradeBeacon).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsFoodDispenser => typeof(Building_NutrientPasteDispenser).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsDrug
|
|
{
|
|
get
|
|
{
|
|
if (ingestible != null)
|
|
{
|
|
return ingestible.drugCategory != DrugCategory.None;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsPleasureDrug
|
|
{
|
|
get
|
|
{
|
|
if (IsDrug)
|
|
{
|
|
return ingestible.joy > 0f;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsNonMedicalDrug
|
|
{
|
|
get
|
|
{
|
|
if (IsDrug)
|
|
{
|
|
return ingestible.drugCategory != DrugCategory.Medical;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsTable
|
|
{
|
|
get
|
|
{
|
|
if (surfaceType == SurfaceType.Eat)
|
|
{
|
|
return HasComp(typeof(CompGatherSpot));
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsWorkTable => typeof(Building_WorkTable).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsShell => projectileWhenLoaded != null;
|
|
|
|
public bool IsArt => IsWithinCategory(ThingCategoryDefOf.BuildingsArt);
|
|
|
|
public bool IsSmoothable => building?.smoothedThing != null;
|
|
|
|
public bool IsSmoothed => building?.unsmoothedThing != null;
|
|
|
|
public bool IsMetal
|
|
{
|
|
get
|
|
{
|
|
if (stuffProps != null)
|
|
{
|
|
return stuffProps.categories.Contains(StuffCategoryDefOf.Metallic);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsCryptosleepCasket => typeof(Building_CryptosleepCasket).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsGibbetCage => typeof(Building_GibbetCage).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsMechGestator => typeof(Building_MechGestator).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsMechRecharger => typeof(Building_MechCharger).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsAddictiveDrug
|
|
{
|
|
get
|
|
{
|
|
CompProperties_Drug compProperties = GetCompProperties<CompProperties_Drug>();
|
|
if (compProperties != null)
|
|
{
|
|
return compProperties.addictiveness > 0f;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsMeat
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Item && thingCategories != null)
|
|
{
|
|
return thingCategories.Contains(ThingCategoryDefOf.MeatRaw);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsEgg
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Item && thingCategories != null)
|
|
{
|
|
if (!thingCategories.Contains(ThingCategoryDefOf.EggsFertilized))
|
|
{
|
|
return thingCategories.Contains(ThingCategoryDefOf.EggsUnfertilized);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsLeather
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Item && thingCategories != null)
|
|
{
|
|
return thingCategories.Contains(ThingCategoryDefOf.Leathers);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsWool
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Item && thingCategories != null)
|
|
{
|
|
return thingCategories.Contains(ThingCategoryDefOf.Wools);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsRangedWeapon
|
|
{
|
|
get
|
|
{
|
|
if (!IsWeapon)
|
|
{
|
|
return false;
|
|
}
|
|
if (!verbs.NullOrEmpty())
|
|
{
|
|
for (int i = 0; i < verbs.Count; i++)
|
|
{
|
|
if (!verbs[i].IsMeleeAttack)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsMeleeWeapon
|
|
{
|
|
get
|
|
{
|
|
if (IsWeapon)
|
|
{
|
|
return !IsRangedWeapon;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsWeaponUsingProjectiles
|
|
{
|
|
get
|
|
{
|
|
if (!IsWeapon)
|
|
{
|
|
return false;
|
|
}
|
|
if (!verbs.NullOrEmpty())
|
|
{
|
|
for (int i = 0; i < verbs.Count; i++)
|
|
{
|
|
if (verbs[i].LaunchesProjectile)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsShieldThatBlocksRanged
|
|
{
|
|
get
|
|
{
|
|
if (HasComp(typeof(CompShield)))
|
|
{
|
|
return GetCompProperties<CompProperties_Shield>().blocksRangedWeapons;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsBuildingArtificial
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Building || IsFrame)
|
|
{
|
|
if (building != null)
|
|
{
|
|
if (!building.isNaturalRock)
|
|
{
|
|
return !building.isResourceRock;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsNonResourceNaturalRock
|
|
{
|
|
get
|
|
{
|
|
if (category == ThingCategory.Building && building.isNaturalRock && !building.isResourceRock && !building.mineablePreventNaturalRockOnSurface)
|
|
{
|
|
return !IsSmoothed;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool HasSunShadows
|
|
{
|
|
get
|
|
{
|
|
if (!hasSunShadowsCached.HasValue)
|
|
{
|
|
hasSunShadowsCached = typeof(Pawn).IsAssignableFrom(thingClass);
|
|
}
|
|
return hasSunShadowsCached.Value;
|
|
}
|
|
}
|
|
|
|
public bool IsNaturalOrgan
|
|
{
|
|
get
|
|
{
|
|
if (!isNaturalOrganCached.HasValue)
|
|
{
|
|
if (category != ThingCategory.Item)
|
|
{
|
|
isNaturalOrganCached = false;
|
|
}
|
|
else
|
|
{
|
|
List<BodyPartDef> allDefsListForReading = DefDatabase<BodyPartDef>.AllDefsListForReading;
|
|
isNaturalOrganCached = false;
|
|
for (int i = 0; i < allDefsListForReading.Count; i++)
|
|
{
|
|
if (allDefsListForReading[i].spawnThingOnRemoved == this)
|
|
{
|
|
isNaturalOrganCached = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return isNaturalOrganCached.Value;
|
|
}
|
|
}
|
|
|
|
public bool IsFungus
|
|
{
|
|
get
|
|
{
|
|
if (ingestible != null)
|
|
{
|
|
return ingestible.foodType.HasFlag(FoodTypeFlags.Fungus);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsAnimalProduct
|
|
{
|
|
get
|
|
{
|
|
if (ingestible != null)
|
|
{
|
|
return ingestible.foodType.HasFlag(FoodTypeFlags.AnimalProduct);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsProcessedFood
|
|
{
|
|
get
|
|
{
|
|
if (ingestible != null)
|
|
{
|
|
return ingestible.foodType.HasFlag(FoodTypeFlags.Processed);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool CanAffectLinker
|
|
{
|
|
get
|
|
{
|
|
if (graphicData == null || !graphicData.Linked)
|
|
{
|
|
return IsDoor;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool IsNonDeconstructibleAttackableBuilding
|
|
{
|
|
get
|
|
{
|
|
if (IsBuildingArtificial && !building.IsDeconstructible && destroyable && !mineable && building.isTargetable)
|
|
{
|
|
return building.draftAttackNonDeconstructable;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsPlant => typeof(Plant).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsDeadPlant => typeof(DeadPlant).IsAssignableFrom(thingClass);
|
|
|
|
public bool IsStudiable => HasAssignableCompFrom(typeof(CompStudiable));
|
|
|
|
public List<StyleCategoryDef> RelevantStyleCategories
|
|
{
|
|
get
|
|
{
|
|
if (cachedRelevantStyleCategories == null)
|
|
{
|
|
cachedRelevantStyleCategories = new List<StyleCategoryDef>();
|
|
foreach (StyleCategoryDef allDef in DefDatabase<StyleCategoryDef>.AllDefs)
|
|
{
|
|
if (allDef.thingDefStyles.NullOrEmpty())
|
|
{
|
|
continue;
|
|
}
|
|
foreach (ThingDefStyle thingDefStyle in allDef.thingDefStyles)
|
|
{
|
|
if (thingDefStyle.ThingDef == this)
|
|
{
|
|
cachedRelevantStyleCategories.Add(allDef);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return cachedRelevantStyleCategories;
|
|
}
|
|
}
|
|
|
|
public string LabelAsStuff
|
|
{
|
|
get
|
|
{
|
|
if (!stuffProps.stuffAdjective.NullOrEmpty())
|
|
{
|
|
return stuffProps.stuffAdjective;
|
|
}
|
|
return label;
|
|
}
|
|
}
|
|
|
|
public bool BlocksPlanting(bool canWipePlants = false)
|
|
{
|
|
if (building != null && building.SupportsPlants)
|
|
{
|
|
return false;
|
|
}
|
|
if (building != null && building.isAttachment)
|
|
{
|
|
return false;
|
|
}
|
|
if (blockPlants)
|
|
{
|
|
return true;
|
|
}
|
|
if (!canWipePlants && category == ThingCategory.Plant)
|
|
{
|
|
return true;
|
|
}
|
|
if ((int)Fillage > 0)
|
|
{
|
|
return true;
|
|
}
|
|
if (this.IsEdifice())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public virtual bool CanSpawnAt(IntVec3 pos, Rot4 rot, Map map)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public bool EverStorable(bool willMinifyIfPossible)
|
|
{
|
|
if (typeof(MinifiedThing).IsAssignableFrom(thingClass))
|
|
{
|
|
return true;
|
|
}
|
|
if (!thingCategories.NullOrEmpty())
|
|
{
|
|
if (category == ThingCategory.Item)
|
|
{
|
|
return true;
|
|
}
|
|
if (willMinifyIfPossible && Minifiable)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public Thing GetConcreteExample(ThingDef stuff = null)
|
|
{
|
|
if (concreteExamplesInt == null)
|
|
{
|
|
concreteExamplesInt = new Dictionary<ThingDef, Thing>();
|
|
}
|
|
if (stuff == null)
|
|
{
|
|
stuff = ThingDefOf.Steel;
|
|
}
|
|
if (!concreteExamplesInt.ContainsKey(stuff))
|
|
{
|
|
if (race == null)
|
|
{
|
|
concreteExamplesInt[stuff] = ThingMaker.MakeThing(this, base.MadeFromStuff ? stuff : null);
|
|
}
|
|
else
|
|
{
|
|
concreteExamplesInt[stuff] = PawnGenerator.GeneratePawn(DefDatabase<PawnKindDef>.AllDefsListForReading.FirstOrDefault((PawnKindDef pkd) => pkd.race == this));
|
|
}
|
|
}
|
|
return concreteExamplesInt[stuff];
|
|
}
|
|
|
|
public CompProperties CompDefFor<T>() where T : ThingComp
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i].compClass == typeof(T))
|
|
{
|
|
return comps[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public CompProperties CompDefForAssignableFrom<T>() where T : ThingComp
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (typeof(T).IsAssignableFrom(comps[i].compClass))
|
|
{
|
|
return comps[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public bool HasComp(Type compType)
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i].compClass == compType)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool HasComp<T>() where T : ThingComp
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i].compClass == typeof(T) || typeof(T).IsAssignableFrom(comps[i].compClass))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool HasAssignableCompFrom(Type compType)
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (compType.IsAssignableFrom(comps[i].compClass))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public T GetCompProperties<T>() where T : CompProperties
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
if (comps[i] is T result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override void PostLoad()
|
|
{
|
|
if (graphicData != null)
|
|
{
|
|
LongEventHandler.ExecuteWhenFinished(delegate
|
|
{
|
|
GraphicData graphicData = this.graphicData;
|
|
if (graphicData.shaderType == null)
|
|
{
|
|
graphicData.shaderType = ShaderTypeDefOf.Cutout;
|
|
}
|
|
ContentFinderRequester.requester = this;
|
|
try
|
|
{
|
|
graphic = this.graphicData.Graphic;
|
|
if (drawerType != DrawerType.RealtimeOnly)
|
|
{
|
|
TextureAtlasGroup textureAtlasGroup = category.ToAtlasGroup();
|
|
graphic.TryInsertIntoAtlas(textureAtlasGroup);
|
|
if (textureAtlasGroup == TextureAtlasGroup.Building && Minifiable)
|
|
{
|
|
graphic.TryInsertIntoAtlas(TextureAtlasGroup.Item);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
ContentFinderRequester.requester = null;
|
|
}
|
|
});
|
|
}
|
|
if (tools != null)
|
|
{
|
|
for (int i = 0; i < tools.Count; i++)
|
|
{
|
|
tools[i].id = i.ToString();
|
|
}
|
|
}
|
|
if (verbs != null && verbs.Count == 1 && verbs[0].label.NullOrEmpty())
|
|
{
|
|
verbs[0].label = label;
|
|
}
|
|
base.PostLoad();
|
|
if (category == ThingCategory.Building && building == null)
|
|
{
|
|
building = new BuildingProperties();
|
|
}
|
|
building?.PostLoadSpecial(this);
|
|
apparel?.PostLoadSpecial(this);
|
|
plant?.PostLoadSpecial(this);
|
|
if (comps == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (CompProperties comp in comps)
|
|
{
|
|
comp.PostLoadSpecial(this);
|
|
}
|
|
}
|
|
|
|
protected override void ResolveIcon()
|
|
{
|
|
base.ResolveIcon();
|
|
if (category == ThingCategory.Pawn)
|
|
{
|
|
if (!uiIconPath.NullOrEmpty())
|
|
{
|
|
uiIcon = ContentFinder<Texture2D>.Get(uiIconPath);
|
|
}
|
|
else
|
|
{
|
|
if (race.Humanlike)
|
|
{
|
|
return;
|
|
}
|
|
PawnKindDef anyPawnKind = race.AnyPawnKind;
|
|
if (anyPawnKind != null)
|
|
{
|
|
Material material = ((ModsConfig.BiotechActive && anyPawnKind.RaceProps.IsMechanoid) ? anyPawnKind.lifeStages.First() : anyPawnKind.lifeStages.Last()).bodyGraphicData.Graphic.MatAt(Rot4.East);
|
|
uiIcon = (Texture2D)material.mainTexture;
|
|
uiIconColor = material.color;
|
|
if (ShaderDatabase.TryGetUIShader(material.shader, out var uiShader) && MaterialPool.TryGetRequestForMat(material, out var request))
|
|
{
|
|
request.shader = uiShader;
|
|
uiIconMaterial = MaterialPool.MatFrom(request);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ThingDef thingDef = GenStuff.DefaultStuffFor(this);
|
|
if (colorGenerator != null && (thingDef == null || thingDef.stuffProps.allowColorGenerators))
|
|
{
|
|
uiIconColor = colorGenerator.ExemplaryColor;
|
|
}
|
|
else if (thingDef != null)
|
|
{
|
|
uiIconColor = GetColorForStuff(thingDef);
|
|
}
|
|
else if (graphicData != null)
|
|
{
|
|
uiIconColor = graphicData.color;
|
|
}
|
|
if (rotatable && graphic != null && graphic != BaseContent.BadGraphic && graphic.ShouldDrawRotated && defaultPlacingRot == Rot4.South)
|
|
{
|
|
uiIconAngle = 180f + graphic.DrawRotatedExtraAngleOffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void ResolveReferences()
|
|
{
|
|
base.ResolveReferences();
|
|
if (ingestible != null)
|
|
{
|
|
ingestible.parent = this;
|
|
}
|
|
if (stuffProps != null)
|
|
{
|
|
stuffProps.parent = this;
|
|
}
|
|
building?.ResolveReferencesSpecial();
|
|
graphicData?.ResolveReferencesSpecial();
|
|
race?.ResolveReferencesSpecial();
|
|
stuffProps?.ResolveReferencesSpecial();
|
|
apparel?.ResolveReferencesSpecial();
|
|
if (soundImpactDefault == null)
|
|
{
|
|
soundImpactDefault = SoundDefOf.BulletImpact_Ground;
|
|
}
|
|
if (soundDrop == null)
|
|
{
|
|
soundDrop = SoundDefOf.Standard_Drop;
|
|
}
|
|
if (soundPickup == null)
|
|
{
|
|
soundPickup = SoundDefOf.Standard_Pickup;
|
|
}
|
|
if (soundInteract == null)
|
|
{
|
|
soundInteract = SoundDefOf.Standard_Pickup;
|
|
}
|
|
if (inspectorTabs != null && inspectorTabs.Any())
|
|
{
|
|
inspectorTabsResolved = new List<InspectTabBase>();
|
|
for (int i = 0; i < inspectorTabs.Count; i++)
|
|
{
|
|
try
|
|
{
|
|
inspectorTabsResolved.Add(InspectTabManager.GetSharedInstance(inspectorTabs[i]));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error("Could not instantiate inspector tab of type " + inspectorTabs[i]?.ToString() + ": " + ex);
|
|
}
|
|
}
|
|
}
|
|
if (comps != null)
|
|
{
|
|
for (int j = 0; j < comps.Count; j++)
|
|
{
|
|
comps[j].ResolveReferences(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override IEnumerable<string> ConfigErrors()
|
|
{
|
|
foreach (string item in base.ConfigErrors())
|
|
{
|
|
yield return item;
|
|
}
|
|
if (category != ThingCategory.Ethereal && label.NullOrEmpty())
|
|
{
|
|
yield return "no label";
|
|
}
|
|
if (category == ThingCategory.Building && !IsFrame && building.IsDeconstructible && thingClass != null && typeof(Building).IsSubclassOf(thingClass))
|
|
{
|
|
yield return "has building category and is marked as deconstructible, but thing class is not a subclass of building (" + thingClass.Name + ")";
|
|
}
|
|
if (graphicData != null)
|
|
{
|
|
foreach (string item2 in graphicData.ConfigErrors(this))
|
|
{
|
|
yield return item2;
|
|
}
|
|
}
|
|
if (projectile != null)
|
|
{
|
|
foreach (string item3 in projectile.ConfigErrors(this))
|
|
{
|
|
yield return item3;
|
|
}
|
|
}
|
|
if (statBases != null)
|
|
{
|
|
foreach (StatModifier statBase in statBases)
|
|
{
|
|
if (statBases.Count((StatModifier st) => st.stat == statBase.stat) > 1)
|
|
{
|
|
yield return "defines the stat base " + statBase.stat?.ToString() + " more than once.";
|
|
}
|
|
}
|
|
}
|
|
if (!BeautyUtility.BeautyRelevant(category) && this.StatBaseDefined(StatDefOf.Beauty))
|
|
{
|
|
yield return "Beauty stat base is defined, but Things of category " + category.ToString() + " cannot have beauty.";
|
|
}
|
|
if (!BeautyUtility.BeautyRelevant(category) && this.StatBaseDefined(StatDefOf.BeautyOutdoors))
|
|
{
|
|
yield return "BeautyOutdoors stat base is defined, but Things of category " + category.ToString() + " cannot have beauty.";
|
|
}
|
|
if (char.IsNumber(defName[defName.Length - 1]))
|
|
{
|
|
yield return "ends with a numerical digit, which is not allowed on ThingDefs.";
|
|
}
|
|
if (thingClass == null)
|
|
{
|
|
yield return "has null thingClass.";
|
|
}
|
|
if (comps.Count > 0 && !typeof(ThingWithComps).IsAssignableFrom(thingClass))
|
|
{
|
|
yield return "has components but it's thingClass is not a ThingWithComps";
|
|
}
|
|
if (ConnectToPower && drawerType == DrawerType.RealtimeOnly && IsFrame)
|
|
{
|
|
yield return "connects to power but does not add to map mesh. Will not create wire meshes.";
|
|
}
|
|
if (costList != null)
|
|
{
|
|
foreach (ThingDefCountClass cost in costList)
|
|
{
|
|
if (cost.count == 0)
|
|
{
|
|
yield return "cost in " + cost.thingDef?.ToString() + " is zero.";
|
|
}
|
|
}
|
|
}
|
|
ThingCategoryDef thingCategoryDef = thingCategories?.FirstOrDefault((ThingCategoryDef cat) => thingCategories.Count((ThingCategoryDef c) => c == cat) > 1);
|
|
if (thingCategoryDef != null)
|
|
{
|
|
yield return "has duplicate thingCategory " + thingCategoryDef?.ToString() + ".";
|
|
}
|
|
if (Fillage == FillCategory.Full && category != ThingCategory.Building)
|
|
{
|
|
yield return "gives full cover but is not a building.";
|
|
}
|
|
if (equipmentType != 0)
|
|
{
|
|
if (techLevel == TechLevel.Undefined && !destroyOnDrop)
|
|
{
|
|
yield return "is equipment but has no tech level.";
|
|
}
|
|
if (!comps.Any((CompProperties c) => typeof(CompEquippable).IsAssignableFrom(c.compClass)))
|
|
{
|
|
yield return "is equipment but has no CompEquippable";
|
|
}
|
|
}
|
|
if (thingClass == typeof(Bullet) && projectile.damageDef == null)
|
|
{
|
|
yield return " is a bullet but has no damageDef.";
|
|
}
|
|
if (destroyOnDrop && tradeability != 0)
|
|
{
|
|
yield return "destroyOnDrop but tradeability is " + tradeability;
|
|
}
|
|
if (stackLimit > 1 && !drawGUIOverlay)
|
|
{
|
|
yield return "has stackLimit > 1 but also has drawGUIOverlay = false.";
|
|
}
|
|
if (damageMultipliers != null)
|
|
{
|
|
foreach (DamageMultiplier mult in damageMultipliers)
|
|
{
|
|
if (damageMultipliers.Count((DamageMultiplier m) => m.damageDef == mult.damageDef) > 1)
|
|
{
|
|
yield return "has multiple damage multipliers for damageDef " + mult.damageDef;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (Fillage == FillCategory.Full && !this.IsEdifice())
|
|
{
|
|
yield return "fillPercent is 1.00 but is not edifice";
|
|
}
|
|
if (base.MadeFromStuff && constructEffect != null)
|
|
{
|
|
yield return "madeFromStuff but has a defined constructEffect (which will always be overridden by stuff's construct animation).";
|
|
}
|
|
if (base.MadeFromStuff && stuffCategories.NullOrEmpty())
|
|
{
|
|
yield return "madeFromStuff but has no stuffCategories.";
|
|
}
|
|
if (costList.NullOrEmpty() && costStuffCount <= 0 && recipeMaker != null)
|
|
{
|
|
yield return "has a recipeMaker but no costList or costStuffCount.";
|
|
}
|
|
if (costStuffCount > 0 && stuffCategories.NullOrEmpty())
|
|
{
|
|
yield return "has costStuffCount but no stuffCategories.";
|
|
}
|
|
if (this.GetStatValueAbstract(StatDefOf.DeteriorationRate) > 1E-05f && !CanEverDeteriorate && !destroyOnDrop)
|
|
{
|
|
yield return "has >0 DeteriorationRate but can't deteriorate.";
|
|
}
|
|
if (smeltProducts != null && !smeltable)
|
|
{
|
|
yield return "has smeltProducts but has smeltable=false";
|
|
}
|
|
if (smeltable && smeltProducts.NullOrEmpty() && base.CostList.NullOrEmpty() && !IsStuff && !base.MadeFromStuff && !destroyOnDrop)
|
|
{
|
|
yield return "is smeltable but does not give anything for smelting.";
|
|
}
|
|
if (equipmentType != 0 && verbs.NullOrEmpty() && tools.NullOrEmpty())
|
|
{
|
|
yield return "is equipment but has no verbs or tools";
|
|
}
|
|
if (Minifiable && thingCategories.NullOrEmpty())
|
|
{
|
|
yield return "is minifiable but not in any thing category";
|
|
}
|
|
if (category == ThingCategory.Building && !Minifiable && !thingCategories.NullOrEmpty())
|
|
{
|
|
yield return "is not minifiable yet has thing categories (could be confusing in thing filters because it can't be moved/stored anyway)";
|
|
}
|
|
if (!destroyOnDrop && !typeof(MinifiedThing).IsAssignableFrom(thingClass) && (EverHaulable || Minifiable) && (statBases.NullOrEmpty() || !statBases.Any((StatModifier s) => s.stat == StatDefOf.Mass)))
|
|
{
|
|
yield return "is haulable, but does not have an authored mass value";
|
|
}
|
|
if (ingestible == null && this.GetStatValueAbstract(StatDefOf.Nutrition) != 0f)
|
|
{
|
|
yield return "has nutrition but ingestible properties are null";
|
|
}
|
|
if (BaseFlammability != 0f && !useHitPoints && category != ThingCategory.Pawn && !destroyOnDrop)
|
|
{
|
|
yield return "flammable but has no hitpoints (will burn indefinitely)";
|
|
}
|
|
if (graphicData?.shadowData != null && staticSunShadowHeight > 0f)
|
|
{
|
|
yield return "graphicData defines a shadowInfo but staticSunShadowHeight > 0";
|
|
}
|
|
if (saveCompressible && Claimable)
|
|
{
|
|
yield return "claimable item is compressible; faction will be unset after load";
|
|
}
|
|
if (deepCommonality > 0f != deepLumpSizeRange.TrueMax > 0)
|
|
{
|
|
yield return "if deepCommonality or deepLumpSizeRange is set, the other also must be set";
|
|
}
|
|
if (deepCommonality > 0f && deepCountPerPortion <= 0)
|
|
{
|
|
yield return "deepCommonality > 0 but deepCountPerPortion is not set";
|
|
}
|
|
if (verbs != null)
|
|
{
|
|
for (int i = 0; i < verbs.Count; i++)
|
|
{
|
|
foreach (string item4 in verbs[i].ConfigErrors(this))
|
|
{
|
|
yield return $"verb {i}: {item4}";
|
|
}
|
|
}
|
|
}
|
|
if (building != null)
|
|
{
|
|
foreach (string item5 in building.ConfigErrors(this))
|
|
{
|
|
yield return item5;
|
|
}
|
|
if ((building.isAirtight || building.isStuffableAirtight) && Fillage != FillCategory.Full)
|
|
{
|
|
yield return "is airtight but Fillage is not Full";
|
|
}
|
|
}
|
|
if (apparel != null)
|
|
{
|
|
foreach (string item6 in apparel.ConfigErrors(this))
|
|
{
|
|
yield return item6;
|
|
}
|
|
}
|
|
if (comps != null)
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
foreach (string item7 in comps[i].ConfigErrors(this))
|
|
{
|
|
yield return item7;
|
|
}
|
|
}
|
|
}
|
|
if (race != null)
|
|
{
|
|
foreach (string item8 in race.ConfigErrors(this))
|
|
{
|
|
yield return item8;
|
|
}
|
|
if (race.body != null && race != null && tools != null)
|
|
{
|
|
int i;
|
|
for (i = 0; i < tools.Count; i++)
|
|
{
|
|
if (tools[i].linkedBodyPartsGroup != null && !race.body.AllParts.Any((BodyPartRecord part) => part.groups.Contains(tools[i].linkedBodyPartsGroup)))
|
|
{
|
|
yield return "has tool with linkedBodyPartsGroup " + tools[i].linkedBodyPartsGroup?.ToString() + " but body " + race.body?.ToString() + " has no parts with that group.";
|
|
}
|
|
}
|
|
}
|
|
if (race.Animal && this.GetStatValueAbstract(StatDefOf.Wildness) < 0f)
|
|
{
|
|
yield return "is animal but wildness is not defined";
|
|
}
|
|
}
|
|
if (ingestible != null)
|
|
{
|
|
foreach (string item9 in ingestible.ConfigErrors())
|
|
{
|
|
yield return item9;
|
|
}
|
|
}
|
|
if (plant != null)
|
|
{
|
|
foreach (string item10 in plant.ConfigErrors())
|
|
{
|
|
yield return item10;
|
|
}
|
|
}
|
|
if (tools != null)
|
|
{
|
|
Tool tool = tools.SelectMany((Tool lhs) => tools.Where((Tool rhs) => lhs != rhs && lhs.id == rhs.id)).FirstOrDefault();
|
|
if (tool != null)
|
|
{
|
|
yield return "duplicate thingdef tool id " + tool.id;
|
|
}
|
|
foreach (Tool tool2 in tools)
|
|
{
|
|
foreach (string item11 in tool2.ConfigErrors())
|
|
{
|
|
yield return item11;
|
|
}
|
|
}
|
|
}
|
|
if (!randomStyle.NullOrEmpty())
|
|
{
|
|
foreach (ThingStyleChance item12 in randomStyle)
|
|
{
|
|
if (item12.Chance <= 0f)
|
|
{
|
|
yield return "style chance <= 0.";
|
|
}
|
|
}
|
|
if (!comps.Any((CompProperties c) => c.compClass == typeof(CompStyleable)))
|
|
{
|
|
yield return "random style assigned, but missing CompStyleable!";
|
|
}
|
|
}
|
|
if (relicChance > 0f && category != ThingCategory.Item)
|
|
{
|
|
yield return "relic chance > 0 but category != item";
|
|
}
|
|
if (hasInteractionCell && !multipleInteractionCellOffsets.NullOrEmpty())
|
|
{
|
|
yield return "both single and multiple interaction cells are defined, it should be one or the other";
|
|
}
|
|
if (Fillage != FillCategory.Full && passability == Traversability.Impassable && !IsDoor && base.BuildableByPlayer && !disableImpassableShotOverConfigError)
|
|
{
|
|
yield return "impassable, player-buildable building that can be shot/seen over.";
|
|
}
|
|
}
|
|
|
|
public static ThingDef Named(string defName)
|
|
{
|
|
return DefDatabase<ThingDef>.GetNamed(defName);
|
|
}
|
|
|
|
public bool IsWithinCategory(ThingCategoryDef category)
|
|
{
|
|
if (thingCategories == null)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 0; i < thingCategories.Count; i++)
|
|
{
|
|
for (ThingCategoryDef thingCategoryDef = thingCategories[i]; thingCategoryDef != null; thingCategoryDef = thingCategoryDef.parent)
|
|
{
|
|
if (thingCategoryDef == category)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void Notify_UnlockedByResearch()
|
|
{
|
|
if (comps != null)
|
|
{
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
comps[i].Notify_PostUnlockedByResearch(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override IEnumerable<StatDrawEntry> SpecialDisplayStats(StatRequest req)
|
|
{
|
|
foreach (StatDrawEntry item in base.SpecialDisplayStats(req))
|
|
{
|
|
yield return item;
|
|
}
|
|
if (apparel != null)
|
|
{
|
|
string coveredOuterPartsString = apparel.GetCoveredOuterPartsString(BodyDefOf.Human);
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Apparel, "Covers".Translate(), coveredOuterPartsString, "Stat_Thing_Apparel_Covers_Desc".Translate(), 2750);
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Apparel, "Layer".Translate(), apparel.GetLayersString(), "Stat_Thing_Apparel_Layer_Desc".Translate(), 2751);
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Apparel, "Stat_Thing_Apparel_CountsAsClothingNudity_Name".Translate(), apparel.countsAsClothingForNudity ? "Yes".Translate() : "No".Translate(), "Stat_Thing_Apparel_CountsAsClothingNudity_Desc".Translate(), 2753);
|
|
if (ModsConfig.BiotechActive)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Apparel, "Stat_Thing_Apparel_ValidLifestage".Translate(), apparel.developmentalStageFilter.ToCommaList().CapitalizeFirst(), "Stat_Thing_Apparel_ValidLifestage_Desc".Translate(), 2748);
|
|
}
|
|
if (apparel.gender != 0)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Apparel, "Stat_Thing_Apparel_Gender".Translate(), apparel.gender.GetLabel().CapitalizeFirst(), "Stat_Thing_Apparel_Gender_Desc".Translate(), 2749);
|
|
}
|
|
}
|
|
if (IsMedicine && MedicineTendXpGainFactor != 1f)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "MedicineXpGainFactor".Translate(), MedicineTendXpGainFactor.ToStringPercent(), "Stat_Thing_Drug_MedicineXpGainFactor_Desc".Translate(), 1000);
|
|
}
|
|
if (fillPercent > 0f && (category == ThingCategory.Item || category == ThingCategory.Building || category == ThingCategory.Plant))
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "CoverEffectiveness".Translate(), this.BaseBlockChance().ToStringPercent(), "CoverEffectivenessExplanation".Translate(), 2000);
|
|
}
|
|
if (constructionSkillPrerequisite > 0)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "SkillRequiredToBuild".Translate(SkillDefOf.Construction.LabelCap), constructionSkillPrerequisite.ToString(), "SkillRequiredToBuildExplanation".Translate(SkillDefOf.Construction.LabelCap), 1100);
|
|
}
|
|
if (artisticSkillPrerequisite > 0)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "SkillRequiredToBuild".Translate(SkillDefOf.Artistic.LabelCap), artisticSkillPrerequisite.ToString(), "SkillRequiredToBuildExplanation".Translate(SkillDefOf.Artistic.LabelCap), 1100);
|
|
}
|
|
IEnumerable<RecipeDef> recipes = DefDatabase<RecipeDef>.AllDefsListForReading.Where((RecipeDef r) => r.products.Count == 1 && r.products.Any((ThingDefCountClass p) => p.thingDef == this) && !r.IsSurgery);
|
|
if (recipes.Any())
|
|
{
|
|
IEnumerable<string> enumerable = (from u in recipes.Where((RecipeDef x) => x.recipeUsers != null).SelectMany((RecipeDef r) => r.recipeUsers)
|
|
select u.label).Concat(from x in DefDatabase<ThingDef>.AllDefsListForReading
|
|
where x.recipes != null && x.recipes.Any((RecipeDef y) => y.products.Any((ThingDefCountClass z) => z.thingDef == this))
|
|
select x.label).Distinct();
|
|
if (enumerable.Any())
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "CreatedAt".Translate(), enumerable.ToCommaList().CapitalizeFirst(), "Stat_Thing_CreatedAt_Desc".Translate(), 1103);
|
|
}
|
|
RecipeDef recipeDef = recipes.FirstOrDefault();
|
|
if (recipeDef != null && !recipeDef.ingredients.NullOrEmpty())
|
|
{
|
|
BuildableDef.tmpCostList.Clear();
|
|
BuildableDef.tmpHyperlinks.Clear();
|
|
for (int j = 0; j < recipeDef.ingredients.Count; j++)
|
|
{
|
|
IngredientCount ingredientCount = recipeDef.ingredients[j];
|
|
if (ingredientCount.filter.Summary.NullOrEmpty())
|
|
{
|
|
continue;
|
|
}
|
|
IEnumerable<ThingDef> allowedThingDefs = ingredientCount.filter.AllowedThingDefs;
|
|
if (allowedThingDefs.Any())
|
|
{
|
|
foreach (ThingDef p in allowedThingDefs)
|
|
{
|
|
if (!BuildableDef.tmpHyperlinks.Any((Dialog_InfoCard.Hyperlink x) => x.def == p))
|
|
{
|
|
BuildableDef.tmpHyperlinks.Add(new Dialog_InfoCard.Hyperlink(p));
|
|
}
|
|
}
|
|
}
|
|
BuildableDef.tmpCostList.Add(recipeDef.IngredientValueGetter.BillRequirementsDescription(recipeDef, ingredientCount));
|
|
}
|
|
}
|
|
if (BuildableDef.tmpCostList.Any())
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "Ingredients".Translate(), BuildableDef.tmpCostList.ToCommaList(), "Stat_Thing_Ingredients".Translate(), 1102, null, BuildableDef.tmpHyperlinks);
|
|
}
|
|
}
|
|
if (thingClass != null && typeof(Building_Bed).IsAssignableFrom(thingClass) && !statBases.StatListContains(StatDefOf.BedRestEffectiveness))
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Building, StatDefOf.BedRestEffectiveness, StatDefOf.BedRestEffectiveness.valueIfMissing, StatRequest.ForEmpty());
|
|
}
|
|
if (!verbs.NullOrEmpty())
|
|
{
|
|
VerbProperties verb = verbs.First((VerbProperties x) => x.isPrimary);
|
|
StatCategoryDef verbStatCategory = ((category == ThingCategory.Pawn) ? StatCategoryDefOf.PawnCombat : null);
|
|
float num = verb.warmupTime;
|
|
StringBuilder stringBuilder = new StringBuilder("Stat_Thing_Weapon_RangedWarmupTime_Desc".Translate());
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine("StatsReport_BaseValue".Translate() + ": " + num.ToString("0.##") + " " + "LetterSecond".Translate());
|
|
if (num > 0f)
|
|
{
|
|
if (req.HasThing)
|
|
{
|
|
float statValue = req.Thing.GetStatValue(StatDefOf.RangedWeapon_WarmupMultiplier);
|
|
num *= statValue;
|
|
if (!Mathf.Approximately(statValue, 1f))
|
|
{
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine("Stat_Thing_Weapon_WarmupTime_Multiplier".Translate() + ": x" + statValue.ToStringPercent());
|
|
stringBuilder.Append(StatUtility.GetOffsetsAndFactorsFor(StatDefOf.RangedWeapon_WarmupMultiplier, req.Thing));
|
|
}
|
|
}
|
|
stringBuilder.AppendLine();
|
|
stringBuilder.AppendLine("StatsReport_FinalValue".Translate() + ": " + num.ToString("0.##") + " " + "LetterSecond".Translate());
|
|
yield return new StatDrawEntry(verbStatCategory ?? StatCategoryDefOf.Weapon_Ranged, "RangedWarmupTime".Translate(), num.ToString("0.##") + " " + "LetterSecond".Translate(), stringBuilder.ToString(), 3555);
|
|
}
|
|
if (verb.defaultProjectile?.projectile.damageDef != null && verb.defaultProjectile.projectile.damageDef.harmsHealth)
|
|
{
|
|
StatCategoryDef statCat = verbStatCategory ?? StatCategoryDefOf.Weapon_Ranged;
|
|
StringBuilder stringBuilder2 = new StringBuilder();
|
|
stringBuilder2.AppendLine("Stat_Thing_Damage_Desc".Translate());
|
|
stringBuilder2.AppendLine();
|
|
float num2 = verb.defaultProjectile.projectile.GetDamageAmount(req.Thing, stringBuilder2);
|
|
yield return new StatDrawEntry(statCat, "Damage".Translate(), num2.ToString(), stringBuilder2.ToString(), 5500);
|
|
if (verb.defaultProjectile.projectile.damageDef.armorCategory != null)
|
|
{
|
|
StringBuilder stringBuilder3 = new StringBuilder();
|
|
float armorPenetration = verb.defaultProjectile.projectile.GetArmorPenetration(req.Thing, stringBuilder3);
|
|
TaggedString taggedString = "ArmorPenetrationExplanation".Translate();
|
|
if (stringBuilder3.Length != 0)
|
|
{
|
|
taggedString += "\n\n" + stringBuilder3;
|
|
}
|
|
yield return new StatDrawEntry(statCat, "ArmorPenetration".Translate(), armorPenetration.ToStringPercent(), taggedString, 5400);
|
|
}
|
|
float buildingDamageFactor = verb.defaultProjectile.projectile.damageDef.buildingDamageFactor;
|
|
float dmgBuildingsImpassable = verb.defaultProjectile.projectile.damageDef.buildingDamageFactorImpassable;
|
|
float dmgBuildingsPassable = verb.defaultProjectile.projectile.damageDef.buildingDamageFactorPassable;
|
|
if (buildingDamageFactor != 1f)
|
|
{
|
|
yield return new StatDrawEntry(statCat, "BuildingDamageFactor".Translate(), buildingDamageFactor.ToStringPercent(), "BuildingDamageFactorExplanation".Translate(), 5410);
|
|
}
|
|
if (dmgBuildingsImpassable != 1f)
|
|
{
|
|
yield return new StatDrawEntry(statCat, "BuildingDamageFactorImpassable".Translate(), dmgBuildingsImpassable.ToStringPercent(), "BuildingDamageFactorImpassableExplanation".Translate(), 5420);
|
|
}
|
|
if (dmgBuildingsPassable != 1f)
|
|
{
|
|
yield return new StatDrawEntry(statCat, "BuildingDamageFactorPassable".Translate(), dmgBuildingsPassable.ToStringPercent(), "BuildingDamageFactorPassableExplanation".Translate(), 5430);
|
|
}
|
|
}
|
|
if (verb.defaultProjectile == null && verb.beamDamageDef != null)
|
|
{
|
|
yield return new StatDrawEntry(verbStatCategory ?? StatCategoryDefOf.Weapon_Ranged, "ArmorPenetration".Translate(), verb.beamDamageDef.defaultArmorPenetration.ToStringPercent(), "ArmorPenetrationExplanation".Translate(), 5400);
|
|
}
|
|
if (verb.Ranged)
|
|
{
|
|
float num3 = verb.burstShotCount;
|
|
float num4 = verb.ticksBetweenBurstShots;
|
|
float dmgBuildingsPassable = (verb?.defaultProjectile?.projectile?.stoppingPower).GetValueOrDefault();
|
|
StringBuilder stringBuilder4 = new StringBuilder("Stat_Thing_Weapon_BurstShotFireRate_Desc".Translate());
|
|
stringBuilder4.AppendLine();
|
|
stringBuilder4.AppendLine();
|
|
stringBuilder4.AppendLine("StatsReport_BaseValue".Translate() + ": " + verb.burstShotCount.ToString());
|
|
stringBuilder4.AppendLine();
|
|
StringBuilder ticksBetweenBurstShotsExplanation = new StringBuilder("Stat_Thing_Weapon_BurstShotFireRate_Desc".Translate());
|
|
ticksBetweenBurstShotsExplanation.AppendLine();
|
|
ticksBetweenBurstShotsExplanation.AppendLine();
|
|
ticksBetweenBurstShotsExplanation.AppendLine("StatsReport_BaseValue".Translate() + ": " + (60f / verb.ticksBetweenBurstShots.TicksToSeconds()).ToString("0.##") + " rpm");
|
|
ticksBetweenBurstShotsExplanation.AppendLine();
|
|
StringBuilder stoppingPowerExplanation = new StringBuilder("StoppingPowerExplanation".Translate());
|
|
stoppingPowerExplanation.AppendLine();
|
|
stoppingPowerExplanation.AppendLine();
|
|
stoppingPowerExplanation.AppendLine("StatsReport_BaseValue".Translate() + ": " + dmgBuildingsPassable.ToString("F1"));
|
|
stoppingPowerExplanation.AppendLine();
|
|
if (req.HasThing && req.Thing.TryGetComp(out CompUniqueWeapon comp))
|
|
{
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
bool flag3 = false;
|
|
foreach (WeaponTraitDef item2 in comp.TraitsListForReading)
|
|
{
|
|
if (!Mathf.Approximately(item2.burstShotCountMultiplier, 1f))
|
|
{
|
|
if (!flag)
|
|
{
|
|
stringBuilder4.AppendLine("StatsReport_WeaponTraits".Translate() + ":");
|
|
flag = true;
|
|
}
|
|
num3 *= item2.burstShotCountMultiplier;
|
|
stringBuilder4.AppendLine(" " + item2.LabelCap + ": " + item2.burstShotCountMultiplier.ToStringByStyle(ToStringStyle.PercentOne, ToStringNumberSense.Factor));
|
|
}
|
|
if (!Mathf.Approximately(item2.burstShotSpeedMultiplier, 1f))
|
|
{
|
|
if (!flag2)
|
|
{
|
|
ticksBetweenBurstShotsExplanation.AppendLine("StatsReport_WeaponTraits".Translate() + ":");
|
|
flag2 = true;
|
|
}
|
|
num4 /= item2.burstShotSpeedMultiplier;
|
|
ticksBetweenBurstShotsExplanation.AppendLine(" " + item2.LabelCap + ": " + item2.burstShotSpeedMultiplier.ToStringByStyle(ToStringStyle.PercentOne, ToStringNumberSense.Factor));
|
|
}
|
|
if (!Mathf.Approximately(item2.additionalStoppingPower, 0f))
|
|
{
|
|
if (!flag3)
|
|
{
|
|
stoppingPowerExplanation.AppendLine("StatsReport_WeaponTraits".Translate() + ":");
|
|
flag3 = true;
|
|
}
|
|
dmgBuildingsPassable += item2.additionalStoppingPower;
|
|
stoppingPowerExplanation.AppendLine(" " + item2.LabelCap + ": " + item2.additionalStoppingPower.ToStringByStyle(ToStringStyle.FloatOne, ToStringNumberSense.Offset));
|
|
}
|
|
}
|
|
}
|
|
stringBuilder4.AppendLine();
|
|
stringBuilder4.AppendLine("StatsReport_FinalValue".Translate() + ": " + Mathf.CeilToInt(num3).ToString());
|
|
float dmgBuildingsImpassable = 60f / ((int)num4).TicksToSeconds();
|
|
ticksBetweenBurstShotsExplanation.AppendLine();
|
|
ticksBetweenBurstShotsExplanation.AppendLine("StatsReport_FinalValue".Translate() + ": " + dmgBuildingsImpassable.ToString("0.##") + " rpm");
|
|
stoppingPowerExplanation.AppendLine();
|
|
stoppingPowerExplanation.AppendLine("StatsReport_FinalValue".Translate() + ": " + dmgBuildingsPassable.ToString("F1"));
|
|
StatCategoryDef statCat = verbStatCategory ?? StatCategoryDefOf.Weapon_Ranged;
|
|
if (verb.showBurstShotStats && verb.burstShotCount > 1)
|
|
{
|
|
yield return new StatDrawEntry(statCat, "BurstShotCount".Translate(), Mathf.CeilToInt(num3).ToString(), stringBuilder4.ToString(), 5391);
|
|
yield return new StatDrawEntry(statCat, "BurstShotFireRate".Translate(), dmgBuildingsImpassable.ToString("0.##") + " rpm", ticksBetweenBurstShotsExplanation.ToString(), 5395);
|
|
}
|
|
if (dmgBuildingsPassable > 0f)
|
|
{
|
|
yield return new StatDrawEntry(statCat, "StoppingPower".Translate(), dmgBuildingsPassable.ToString("F1"), stoppingPowerExplanation.ToString(), 5402);
|
|
}
|
|
float num5 = verb.range;
|
|
StringBuilder stringBuilder5 = new StringBuilder("Stat_Thing_Weapon_Range_Desc".Translate());
|
|
stringBuilder5.AppendLine();
|
|
stringBuilder5.AppendLine();
|
|
stringBuilder5.AppendLine("StatsReport_BaseValue".Translate() + ": " + num5.ToString("F0"));
|
|
if (req.HasThing)
|
|
{
|
|
float statValue2 = req.Thing.GetStatValue(StatDefOf.RangedWeapon_RangeMultiplier);
|
|
num5 *= statValue2;
|
|
if (!Mathf.Approximately(statValue2, 1f))
|
|
{
|
|
stringBuilder5.AppendLine();
|
|
stringBuilder5.AppendLine("Stat_Thing_Weapon_Range_Multiplier".Translate() + ": x" + statValue2.ToStringPercent());
|
|
stringBuilder5.Append(StatUtility.GetOffsetsAndFactorsFor(StatDefOf.RangedWeapon_RangeMultiplier, req.Thing));
|
|
}
|
|
Map obj = req.Thing.Map ?? req.Thing.MapHeld;
|
|
if (obj != null && obj.weatherManager.CurWeatherMaxRangeCap >= 0f)
|
|
{
|
|
WeatherManager weatherManager = (req.Thing.Map ?? req.Thing.MapHeld).weatherManager;
|
|
bool num6 = num5 > weatherManager.CurWeatherMaxRangeCap;
|
|
float num7 = num5;
|
|
num5 = Mathf.Min(num5, weatherManager.CurWeatherMaxRangeCap);
|
|
if (num6)
|
|
{
|
|
stringBuilder5.AppendLine();
|
|
stringBuilder5.AppendLine(" " + "Stat_Thing_Weapon_Range_Clamped".Translate(num5.ToString("F0").Named("CAP"), num7.ToString("F0").Named("ORIGINAL")));
|
|
}
|
|
}
|
|
}
|
|
stringBuilder5.AppendLine();
|
|
stringBuilder5.AppendLine("StatsReport_FinalValue".Translate() + ": " + num5.ToString("F0"));
|
|
yield return new StatDrawEntry(statCat, "Range".Translate(), num5.ToString("F0"), stringBuilder5.ToString(), 5390);
|
|
}
|
|
if (verb.ForcedMissRadius > 0f)
|
|
{
|
|
StatCategoryDef statCat = verbStatCategory ?? StatCategoryDefOf.Weapon_Ranged;
|
|
yield return new StatDrawEntry(statCat, "MissRadius".Translate(), verb.ForcedMissRadius.ToString("0.#"), "Stat_Thing_Weapon_MissRadius_Desc".Translate(), 3557);
|
|
yield return new StatDrawEntry(statCat, "DirectHitChance".Translate(), (1f / (float)GenRadial.NumCellsInRadius(verb.ForcedMissRadius)).ToStringPercent(), "Stat_Thing_Weapon_DirectHitChance_Desc".Translate(), 3560);
|
|
}
|
|
}
|
|
if (plant != null)
|
|
{
|
|
foreach (StatDrawEntry item3 in plant.SpecialDisplayStats())
|
|
{
|
|
yield return item3;
|
|
}
|
|
}
|
|
if (ingestible != null)
|
|
{
|
|
foreach (StatDrawEntry item4 in ingestible.SpecialDisplayStats())
|
|
{
|
|
yield return item4;
|
|
}
|
|
}
|
|
if (race != null)
|
|
{
|
|
foreach (StatDrawEntry item5 in race.SpecialDisplayStats(this, req))
|
|
{
|
|
yield return item5;
|
|
}
|
|
}
|
|
if (building != null)
|
|
{
|
|
foreach (StatDrawEntry item6 in building.SpecialDisplayStats(this, req))
|
|
{
|
|
yield return item6;
|
|
}
|
|
}
|
|
if (isTechHediff)
|
|
{
|
|
IEnumerable<RecipeDef> enumerable2 = DefDatabase<RecipeDef>.AllDefs.Where((RecipeDef x) => x.addsHediff != null && x.IsIngredient(this));
|
|
foreach (StatDrawEntry medicalStatsFromRecipeDef in MedicalRecipesUtility.GetMedicalStatsFromRecipeDefs(enumerable2))
|
|
{
|
|
yield return medicalStatsFromRecipeDef;
|
|
}
|
|
}
|
|
for (int i = 0; i < comps.Count; i++)
|
|
{
|
|
foreach (StatDrawEntry item7 in comps[i].SpecialDisplayStats(req))
|
|
{
|
|
yield return item7;
|
|
}
|
|
}
|
|
if (building != null)
|
|
{
|
|
if (building.mineableThing != null)
|
|
{
|
|
Dialog_InfoCard.Hyperlink[] hyperlinks = new Dialog_InfoCard.Hyperlink[1]
|
|
{
|
|
new Dialog_InfoCard.Hyperlink(building.mineableThing)
|
|
};
|
|
yield return new StatDrawEntry(StatCategoryDefOf.BasicsImportant, "Stat_MineableThing_Name".Translate(), building.mineableThing.LabelCap, "Stat_MineableThing_Desc".Translate(), 2200, null, hyperlinks);
|
|
StringBuilder stringBuilder6 = new StringBuilder();
|
|
stringBuilder6.AppendLine("Stat_MiningYield_Desc".Translate());
|
|
stringBuilder6.AppendLine();
|
|
stringBuilder6.AppendLine("StatsReport_DifficultyMultiplier".Translate(Find.Storyteller.difficultyDef.label) + ": " + Find.Storyteller.difficulty.mineYieldFactor.ToStringByStyle(ToStringStyle.PercentZero, ToStringNumberSense.Factor));
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Basics, "Stat_MiningYield_Name".Translate(), Mathf.CeilToInt(building.EffectiveMineableYield).ToString("F0"), stringBuilder6.ToString(), 2200, null, hyperlinks);
|
|
}
|
|
if (building.IsTurret)
|
|
{
|
|
ThingDef turret = building.turretGunDef;
|
|
yield return new StatDrawEntry(StatCategoryDefOf.BasicsImportant, "Stat_Weapon_Name".Translate(), turret.LabelCap, "Stat_Weapon_Desc".Translate(), 5389, null, new Dialog_InfoCard.Hyperlink[1]
|
|
{
|
|
new Dialog_InfoCard.Hyperlink(turret)
|
|
});
|
|
StatRequest request = StatRequest.For(turret, null);
|
|
foreach (StatDrawEntry item8 in turret.SpecialDisplayStats(request))
|
|
{
|
|
if (item8.category == StatCategoryDefOf.Weapon_Ranged)
|
|
{
|
|
yield return item8;
|
|
}
|
|
}
|
|
for (int i = 0; i < turret.statBases.Count; i++)
|
|
{
|
|
StatModifier statModifier = turret.statBases[i];
|
|
if (statModifier.stat.category == StatCategoryDefOf.Weapon_Ranged)
|
|
{
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Weapon_Ranged, statModifier.stat, statModifier.value, request);
|
|
}
|
|
}
|
|
}
|
|
if (ModsConfig.OdysseyActive && Fillage == FillCategory.Full)
|
|
{
|
|
bool b = building.isAirtight || (building.isStuffableAirtight && req.StuffDef.stuffProps.isAirtight);
|
|
yield return new StatDrawEntry(StatCategoryDefOf.Building, "Stat_Airtight".Translate(), b.ToStringYesNo(), "Stat_Airtight_Desc".Translate(), 6100);
|
|
}
|
|
}
|
|
if (IsMeat)
|
|
{
|
|
List<ThingDef> list = new List<ThingDef>();
|
|
bool flag4 = false;
|
|
foreach (ThingDef allDef in DefDatabase<ThingDef>.AllDefs)
|
|
{
|
|
if (allDef.race != null && allDef.race.meatDef == this && !allDef.IsCorpse)
|
|
{
|
|
if (!Find.HiddenItemsManager.Hidden(allDef))
|
|
{
|
|
flag4 = true;
|
|
}
|
|
list.Add(allDef);
|
|
}
|
|
}
|
|
yield return new StatDrawEntry(valueString: (!flag4) ? string.Format("({0})", "NotYetDiscovered".Translate()) : string.Join(", ", (from x in list
|
|
where !Find.HiddenItemsManager.Hidden(x)
|
|
select x into p
|
|
select p.label).ToArray()).CapitalizeFirst(), category: StatCategoryDefOf.BasicsPawn, label: "Stat_SourceSpecies_Name".Translate(), reportText: "Stat_SourceSpecies_Desc".Translate(), displayPriorityWithinCategory: 1200, overrideReportTitle: null, hyperlinks: Dialog_InfoCard.DefsToHyperlinks(list));
|
|
}
|
|
if (IsLeather)
|
|
{
|
|
List<ThingDef> list2 = new List<ThingDef>();
|
|
bool flag5 = false;
|
|
foreach (ThingDef allDef2 in DefDatabase<ThingDef>.AllDefs)
|
|
{
|
|
if (allDef2.race != null && allDef2.race.leatherDef == this && !allDef2.IsCorpse)
|
|
{
|
|
if (!Find.HiddenItemsManager.Hidden(allDef2))
|
|
{
|
|
flag5 = true;
|
|
}
|
|
list2.Add(allDef2);
|
|
}
|
|
}
|
|
yield return new StatDrawEntry(valueString: (!flag5) ? string.Format("({0})", "NotYetDiscovered".Translate()) : string.Join(", ", (from x in list2
|
|
where !Find.HiddenItemsManager.Hidden(x)
|
|
select x into p
|
|
select p.label).ToArray()).CapitalizeFirst(), category: StatCategoryDefOf.BasicsPawn, label: "Stat_SourceSpecies_Name".Translate(), reportText: "Stat_SourceSpecies_Desc".Translate(), displayPriorityWithinCategory: 1200, overrideReportTitle: null, hyperlinks: Dialog_InfoCard.DefsToHyperlinks(list2));
|
|
}
|
|
if (!equippedStatOffsets.NullOrEmpty())
|
|
{
|
|
for (int i = 0; i < equippedStatOffsets.Count; i++)
|
|
{
|
|
StatDef stat = equippedStatOffsets[i].stat;
|
|
float num8 = equippedStatOffsets[i].value;
|
|
StringBuilder stringBuilder7 = new StringBuilder(stat.description);
|
|
if (req.HasThing && stat.Worker != null)
|
|
{
|
|
stringBuilder7.AppendLine();
|
|
stringBuilder7.AppendLine();
|
|
stringBuilder7.AppendLine("StatsReport_BaseValue".Translate() + ": " + stat.ValueToString(num8, ToStringNumberSense.Offset, stat.finalizeEquippedStatOffset));
|
|
num8 = StatWorker.StatOffsetFromGear(req.Thing, stat);
|
|
if (!stat.parts.NullOrEmpty())
|
|
{
|
|
stringBuilder7.AppendLine();
|
|
for (int k = 0; k < stat.parts.Count; k++)
|
|
{
|
|
string text = stat.parts[k].ExplanationPart(req);
|
|
if (!text.NullOrEmpty())
|
|
{
|
|
stringBuilder7.AppendLine(text);
|
|
}
|
|
}
|
|
}
|
|
stringBuilder7.AppendLine();
|
|
stringBuilder7.AppendLine("StatsReport_FinalValue".Translate() + ": " + stat.ValueToString(num8, ToStringNumberSense.Offset, !stat.formatString.NullOrEmpty()));
|
|
}
|
|
yield return new StatDrawEntry(StatCategoryDefOf.EquippedStatOffsets, equippedStatOffsets[i].stat, num8, StatRequest.ForEmpty(), ToStringNumberSense.Offset, null, forceUnfinalizedMode: true).SetReportText(stringBuilder7.ToString());
|
|
}
|
|
}
|
|
if (!IsDrug)
|
|
{
|
|
yield break;
|
|
}
|
|
foreach (StatDrawEntry item9 in DrugStatsUtility.SpecialDisplayStats(this))
|
|
{
|
|
yield return item9;
|
|
}
|
|
}
|
|
}
|
|
```
|
|
---
|
|
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\Core\Defs\ThingDefs_Races\Races_Animal_Insect.xml`
|
|
**相似度:** 0.5880
|
|
|
|
```xml
|
|
<ThingDef Abstract="True" ParentName="AnimalThingBase" Name="BaseInsect">
|
|
<devNote>insect</devNote>
|
|
<statBases>
|
|
<ToxicResistance>1</ToxicResistance>
|
|
<VacuumResistance MayRequire="Ludeon.RimWorld.Odyssey">1</VacuumResistance>
|
|
<ComfyTemperatureMax>60</ComfyTemperatureMax>
|
|
<ToxicEnvironmentResistance>0.8</ToxicEnvironmentResistance>
|
|
</statBases>
|
|
<race>
|
|
<thinkTreeMain>Insect</thinkTreeMain>
|
|
<thinkTreeConstant>InsectConstant</thinkTreeConstant>
|
|
<fleshType>Insectoid</fleshType>
|
|
<bloodDef>Filth_BloodInsect</bloodDef>
|
|
<meatColor>(160,168,139)</meatColor>
|
|
<meatMarketValue>0.5</meatMarketValue>
|
|
<foodType>OmnivoreAnimal, AnimalProduct</foodType>
|
|
<manhunterOnDamageChance>0.50</manhunterOnDamageChance>
|
|
<soundEating>Insectoid_Eat</soundEating>
|
|
<canBeVacuumBurnt>false</canBeVacuumBurnt>
|
|
</race>
|
|
<ingredient>
|
|
<mergeCompatibilityTags>
|
|
<li MayRequire="Ludeon.RimWorld.Ideology">InsectMeat</li>
|
|
</mergeCompatibilityTags>
|
|
</ingredient>
|
|
<receivesSignals>true</receivesSignals>
|
|
<comps>
|
|
<li Class="CompProperties_CanBeDormant">
|
|
<freezeNeeds>
|
|
<li>Food</li>
|
|
</freezeNeeds>
|
|
</li>
|
|
<li Class="CompProperties_WakeUpDormant">
|
|
<wakeUpOnDamage>true</wakeUpOnDamage>
|
|
<onlySendSignalOnce>false</onlySendSignalOnce>
|
|
</li>
|
|
</comps>
|
|
</ThingDef>
|
|
```
|
|
---
|
|
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\Core\Defs\ThingDefs_Items\Items_Luxury.xml`
|
|
**相似度:** 0.5741
|
|
|
|
```xml
|
|
<ThingDef ParentName="ResourceBase">
|
|
<defName>Chocolate</defName>
|
|
<label>chocolate</label>
|
|
<description>A delicious preparation of cocoa seeds ground together with sugar and vanilla. It fulfills the need for recreation, but it is not very nutritious.</description>
|
|
<graphicData>
|
|
<texPath>Things/Item/Resource/Chocolate</texPath>
|
|
<graphicClass>Graphic_StackCount</graphicClass>
|
|
<drawSize>0.88</drawSize>
|
|
</graphicData>
|
|
<soundInteract>Standard_Drop</soundInteract>
|
|
<soundDrop>Standard_Drop</soundDrop>
|
|
<socialPropernessMatters>true</socialPropernessMatters>
|
|
<statBases>
|
|
<MaxHitPoints>60</MaxHitPoints>
|
|
<MarketValue>3</MarketValue>
|
|
<Mass>0.075</Mass>
|
|
<Flammability>1.0</Flammability>
|
|
<DeteriorationRate>8</DeteriorationRate>
|
|
<Nutrition>0.1</Nutrition>
|
|
</statBases>
|
|
<thingCategories>
|
|
<li>Foods</li>
|
|
</thingCategories>
|
|
<ingestible>
|
|
<preferability>DesperateOnly</preferability>
|
|
<foodType>Processed</foodType>
|
|
<joy>0.10</joy>
|
|
<joyKind>Gluttonous</joyKind>
|
|
<maxNumToIngestAtOnce>4</maxNumToIngestAtOnce>
|
|
<defaultNumToIngestAtOnce>4</defaultNumToIngestAtOnce>
|
|
<ingestSound>Meal_Eat</ingestSound>
|
|
</ingestible>
|
|
<allowedArchonexusCount>80</allowedArchonexusCount>
|
|
<possessionCount>10</possessionCount>
|
|
</ThingDef>
|
|
```
|
|
---
|
|
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompMechGestatorTank.txt`
|
|
**相似度:** 0.5175
|
|
|
|
```csharp
|
|
public class CompMechGestatorTank : ThingComp, IThingGlower
|
|
{
|
|
public enum TankState
|
|
{
|
|
Empty,
|
|
Dormant,
|
|
Proximity
|
|
}
|
|
|
|
private TankState state;
|
|
|
|
private float triggerRadius;
|
|
|
|
private const int StunTicks = 180;
|
|
|
|
private static readonly IntRange GestationFluidFilthRange = new IntRange(2, 4);
|
|
|
|
private CompProperties_MechGestatorTank Props => (CompProperties_MechGestatorTank)props;
|
|
|
|
public TankState State
|
|
{
|
|
get
|
|
{
|
|
return state;
|
|
}
|
|
set
|
|
{
|
|
state = value;
|
|
if (parent.Spawned)
|
|
{
|
|
parent.DirtyMapMesh(parent.Map);
|
|
parent.TryGetComp<CompGlower>()?.UpdateLit(parent.Map);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override string CompInspectStringExtra()
|
|
{
|
|
return string.Format("{0}: {1}", "Contains".Translate(), ((state == TankState.Empty) ? "Nothing" : "Unknown").Translate().CapitalizeFirst());
|
|
}
|
|
|
|
public bool ShouldBeLitNow()
|
|
{
|
|
return state != TankState.Empty;
|
|
}
|
|
|
|
public override bool DontDrawParent()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override void PostPostMake()
|
|
{
|
|
triggerRadius = Props.triggerRadiusRange.RandomInRange;
|
|
}
|
|
|
|
public override void CompTick()
|
|
{
|
|
if (state == TankState.Proximity && parent.IsHashIntervalTick(250))
|
|
{
|
|
CheckTrigger();
|
|
}
|
|
}
|
|
|
|
private void CheckTrigger()
|
|
{
|
|
if (!parent.Spawned)
|
|
{
|
|
return;
|
|
}
|
|
foreach (IntVec3 item in GenRadial.RadialCellsAround(parent.Position, triggerRadius, useCenter: false))
|
|
{
|
|
if (!item.InBounds(parent.Map) || !GenSight.LineOfSight(parent.Position, item, parent.Map))
|
|
{
|
|
continue;
|
|
}
|
|
foreach (Thing thing in item.GetThingList(parent.Map))
|
|
{
|
|
if (thing is Pawn { IsColonist: not false })
|
|
{
|
|
Trigger(parent.Map);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void PostDestroy(DestroyMode mode, Map previousMap)
|
|
{
|
|
if (mode != DestroyMode.WillReplace && state != 0)
|
|
{
|
|
Trigger(previousMap);
|
|
}
|
|
}
|
|
|
|
private void Trigger(Map map)
|
|
{
|
|
if (state == TankState.Empty)
|
|
{
|
|
return;
|
|
}
|
|
State = TankState.Empty;
|
|
IntVec3 loc = parent.OccupiedRect().ExpandedBy(1).EdgeCells.Where(Standable).RandomElementWithFallback(IntVec3.Invalid);
|
|
ScatterDebrisUtility.ScatterFilthAroundThing(parent, map, ThingDefOf.Filth_GestationFluid, GestationFluidFilthRange);
|
|
if (loc.IsValid)
|
|
{
|
|
Pawn pawn = PawnGenerator.GeneratePawn(Props.mechKindOptions.RandomElementByWeight((PawnKindDefWeight x) => x.weight).kindDef, Faction.OfMechanoids);
|
|
GenSpawn.Spawn(pawn, loc, map);
|
|
pawn.stances?.stunner?.StunFor(180, null, addBattleLog: false);
|
|
if (!map.lordManager.TryGetLordByJob<LordJob_AssaultColony>(Faction.OfMechanoids, out var lord))
|
|
{
|
|
LordMaker.MakeNewLord(Faction.OfMechanoids, new LordJob_AssaultColony(Faction.OfMechanoids, canKidnap: false, canTimeoutOrFlee: false, sappers: false, useAvoidGridSmart: false, canSteal: false), map, new List<Pawn> { pawn });
|
|
}
|
|
else
|
|
{
|
|
lord.lord.AddPawn(pawn);
|
|
}
|
|
Messages.Message(Props.triggeredMessage.Formatted(pawn), pawn, MessageTypeDefOf.NegativeEvent);
|
|
Props.triggerSound.PlayOneShot(parent);
|
|
}
|
|
bool Standable(IntVec3 c)
|
|
{
|
|
return c.Standable(map);
|
|
}
|
|
}
|
|
|
|
public override IEnumerable<Gizmo> CompGetGizmosExtra()
|
|
{
|
|
if (!DebugSettings.ShowDevGizmos)
|
|
{
|
|
yield break;
|
|
}
|
|
if (State == TankState.Empty)
|
|
{
|
|
Command_Action command_Action = new Command_Action();
|
|
command_Action.defaultLabel = "DEV: Add mech";
|
|
command_Action.action = delegate
|
|
{
|
|
State = TankState.Proximity;
|
|
};
|
|
yield return command_Action;
|
|
}
|
|
else
|
|
{
|
|
Command_Action command_Action2 = new Command_Action();
|
|
command_Action2.defaultLabel = "DEV: Remove mech";
|
|
command_Action2.action = delegate
|
|
{
|
|
State = TankState.Empty;
|
|
};
|
|
yield return command_Action2;
|
|
}
|
|
}
|
|
|
|
public override void PostPrintOnto(SectionLayer layer)
|
|
{
|
|
((state == TankState.Empty) ? Props.emptyGraphic.Graphic : Props.dormantGraphic.Graphic).Print(layer, parent, 0f);
|
|
}
|
|
|
|
public override void PostExposeData()
|
|
{
|
|
Scribe_Values.Look(ref state, "state", TankState.Empty);
|
|
Scribe_Values.Look(ref triggerRadius, "triggerRadius", 0f);
|
|
}
|
|
}
|
|
``` |