public TerrainPatchMakerWidget(TerrainPatchMaker parent)
{
this.Parent = parent;
this.inputWidgets = new List <IInputWidget>(6)
{
//new FloatInputWidget<TerrainPatchMaker>(this.Parent, "Perlin Frequency", (TerrainPatchMaker p) => p.perlinFrequency, (TerrainPatchMaker p, float f) => p.perlinFrequency = f),
new FloatInputWidget <TerrainPatchMaker>(this.Parent, "Perlin Lacunarity", (TerrainPatchMaker p) => p.perlinLacunarity, (TerrainPatchMaker p, float f) => p.perlinLacunarity = f),
new FloatInputWidget <TerrainPatchMaker>(this.Parent, "Perlin Persistence", (TerrainPatchMaker p) => p.perlinPersistence, (TerrainPatchMaker p, float f) => p.perlinPersistence = f),
new IntInputWidget <TerrainPatchMaker>(this.Parent, "Perlin Octaves", (TerrainPatchMaker p) => p.perlinOctaves, (TerrainPatchMaker p, int i) => p.perlinOctaves = i),
new FloatInputWidget <TerrainPatchMaker>(this.Parent, "Min Fertility", (TerrainPatchMaker p) => p.minFertility, (TerrainPatchMaker p, float f) => p.minFertility = f),
new FloatInputWidget <TerrainPatchMaker>(this.Parent, "Max Fertility", (TerrainPatchMaker p) => p.maxFertility, (TerrainPatchMaker p, float f) => p.maxFertility = f),
new IntInputWidget <TerrainPatchMaker>(this.Parent, "Min Size", (TerrainPatchMaker p) => p.minSize, (TerrainPatchMaker p, int i) => p.minSize = i),
};
if (this.Parent.thresholds != null)
{
this.thresholds = new List <MinMaxInputWidget <TerrainThreshold, float> >(this.Parent.thresholds.Count);
foreach (var v in this.Parent.thresholds)
{
this.thresholds.Add(this.CreateMinMaxInputWidget(v));
}
}
else
{
this.thresholds = new List <MinMaxInputWidget <TerrainThreshold, float> >(0);
}
this.thresholdsArgs = new PlusMinusArgs <TerrainDef>()
{
allItems = DefDatabase <TerrainDef> .AllDefs,
beingUsed = delegate()
{
List <TerrainDef> l = new List <TerrainDef>();
foreach (var v in this.thresholds)
{
l.Add(v.Parent.terrain);
}
return(l);
},
onAdd = delegate(TerrainDef d)
{
TerrainThreshold tt = new TerrainThreshold()
{
terrain = d
};
this.Parent.thresholds.Add(tt);
this.thresholds.Add(this.CreateMinMaxInputWidget(tt));
},
onRemove = delegate(TerrainDef d)
{
this.Parent.thresholds.RemoveAll((TerrainThreshold tt) => tt.terrain == d);
this.thresholds.RemoveAll((MinMaxInputWidget <TerrainThreshold, float> mmw) => mmw.Parent.terrain == d);
},
getDisplayName = (TerrainDef def) => def.label
};
}
public IngestiblePropertiesWidget(IngestibleProperties props)
{
this.Parent = props;
this.inputWidgets = new List <IInputWidget>()
{
new IntInputWidget <IngestibleProperties>(this.Parent, "Max Number Ingest At Once", p => p.maxNumToIngestAtOnce, (p, v) => p.maxNumToIngestAtOnce = v),
new IntInputWidget <IngestibleProperties>(this.Parent, "Base Ingest Ticks", p => p.baseIngestTicks, (p, v) => p.baseIngestTicks = v),
new FloatInputWidget <IngestibleProperties>(this.Parent, "Chair Search Radius", p => p.chairSearchRadius, (p, v) => p.chairSearchRadius = v),
new BoolInputWidget <IngestibleProperties>(this.Parent, "Use Eating Speed Stat", p => p.useEatingSpeedStat, (p, v) => p.useEatingSpeedStat = v),
new BoolInputWidget <IngestibleProperties>(this.Parent, "Ingest Hold Uses Table", p => p.ingestHoldUsesTable, (p, v) => p.ingestHoldUsesTable = v),
new FloatInputWidget <IngestibleProperties>(this.Parent, "Joy", p => p.joy, (p, v) => p.joy = v),
new EnumInputWidget <IngestibleProperties, FoodPreferability>(this.Parent, "Preferability", 200, p => p.preferability, (p, v) => p.preferability = v),
new BoolInputWidget <IngestibleProperties>(this.Parent, "Nurseable", p => p.nurseable, (p, v) => p.nurseable = v),
new FloatInputWidget <IngestibleProperties>(this.Parent, "Optimality Offset Humanlikes", p => p.optimalityOffsetHumanlikes, (p, v) => p.optimalityOffsetHumanlikes = v),
new FloatInputWidget <IngestibleProperties>(this.Parent, "Optimality Offset Feeding Animals", p => p.optimalityOffsetFeedingAnimals, (p, v) => p.optimalityOffsetFeedingAnimals = v),
new EnumInputWidget <IngestibleProperties, DrugCategory>(this.Parent, "DrugCategory", 200, p => p.drugCategory, (p, v) => p.drugCategory = v),
//new DefInputWidget<IngestibleProperties, ThingDef>(this.Parent, "Parent", 200, p => p.parent, (p, v) => { p.parent = v; IngestiblePropertiesStats.ResetCache(p); }, true),
new DefInputWidget <IngestibleProperties, JoyKindDef>(this.Parent, "Joy Kind", 200, p => p.joyKind, (p, v) => p.joyKind = v, true),
new DefInputWidget <IngestibleProperties, ThingDef>(this.Parent, "Source Def", 200, p => p.sourceDef, (p, v) => p.sourceDef = v, true),
new DefInputWidget <IngestibleProperties, ThoughtDef>(this.Parent, "Taste Thought", 200, p => p.tasteThought, (p, v) => p.tasteThought = v, true),
new DefInputWidget <IngestibleProperties, ThoughtDef>(this.Parent, "Special Thought Direct", 200, p => p.specialThoughtDirect, (p, v) => p.specialThoughtDirect = v, true),
new DefInputWidget <IngestibleProperties, ThoughtDef>(this.Parent, "Special Thought As Ingredient", 200, p => p.specialThoughtAsIngredient, (p, v) => p.specialThoughtAsIngredient = v, true),
new DefInputWidget <IngestibleProperties, EffecterDef>(this.Parent, "Ingest Effect", 200, p => p.ingestEffect, (p, v) => p.ingestEffect = v, true),
new DefInputWidget <IngestibleProperties, EffecterDef>(this.Parent, "Ingest Effect Eat", 200, p => p.ingestEffectEat, (p, v) => p.ingestEffectEat = v, true),
new DefInputWidget <IngestibleProperties, SoundDef>(this.Parent, "Sound Def", 200, p => p.ingestSound, (p, v) => p.ingestSound = v, true),
};
var dic = new SortedDictionary <string, FoodTypeFlags>();
foreach (var v in Enum.GetValues(typeof(FoodTypeFlags)).Cast <FoodTypeFlags>())
{
dic.Add(v.ToString(), v);
}
this.foodTypeSortedFlags = new List <FoodTypeFlags>(dic.Values);
dic.Clear();
dic = null;
this.foodTypePlusMinus = new PlusMinusArgs <FoodTypeFlags>()
{
allItems = this.foodTypeSortedFlags,
isBeingUsed = v => (this.Parent.foodType & v) == v,
onAdd = v => this.Parent.foodType |= v,
onRemove = v => this.Parent.foodType &= ~v,
getDisplayName = v => v.ToString()
};
}
public BackstoryWidget(Backstory backstory, DefType type) : base(backstory, type)
{
if (backstory.skillGainsResolved == null)
{
backstory.skillGainsResolved = new Dictionary <SkillDef, int>();
}
if (backstory.forcedTraits == null)
{
backstory.forcedTraits = new List <TraitEntry>();
}
if (backstory.disallowedTraits == null)
{
backstory.disallowedTraits = new List <TraitEntry>();
}
this.Backstory = backstory;
this.type = type;
this.inputWidgets = new List <IInputWidget>()
{
new BoolInputWidget <Backstory>(this.Backstory, "Shuffleable", b => b.shuffleable, (b, v) => b.shuffleable = v),
new EnumInputWidget <Backstory, BackstorySlot>(this.Backstory, "Slot", 200, b => b.slot, (b, v) => b.slot = v),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Global", 200, b => BackstoryStats.GetBodyTypeGlobal(b), (b, v) => BackstoryStats.SetBodyTypeGlobal(b, v), true),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Male", 200, b => BackstoryStats.GetBodyTypeMale(b), (b, v) => BackstoryStats.SetBodyTypeMale(b, v), true, d => d == BodyTypeDefOf.Female),
new DefInputWidget <Backstory, BodyTypeDef>(this.Backstory, "Body Type Female", 200, b => BackstoryStats.GetBodyTypeFemale(b), (b, v) => BackstoryStats.SetBodyTypeFemale(b, v), true, d => d == BodyTypeDefOf.Male),
};
var dic = new SortedDictionary <string, WorkTags>();
foreach (var v in Enum.GetValues(typeof(WorkTags)).Cast <WorkTags>())
{
dic.Add(v.ToString(), v);
}
this.workTags = new List <WorkTags>(dic.Values);
dic.Clear();
dic = null;
this.workDisables = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (this.Backstory.workDisables & v) == v,
onAdd = v => this.Backstory.workDisables |= v,
onRemove = v => this.Backstory.workDisables &= ~v,
getDisplayName = v => v.ToString()
};
this.requiredWorkTags = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (this.Backstory.requiredWorkTags & v) == v,
onAdd = v => this.Backstory.requiredWorkTags |= v,
onRemove = v => this.Backstory.requiredWorkTags &= ~v,
getDisplayName = v => v.ToString()
};
this.skillGainsPlusMinus = new PlusMinusArgs <SkillDef>()
{
allItems = Util.SortedDefList <SkillDef>(),
beingUsed = () => this.Backstory.skillGainsResolved.Keys,
onAdd = v =>
{
this.Backstory.skillGainsResolved[v] = 0;
this.skillGains.Add(this.CreateSkillGainsInput(v));
},
onRemove = v =>
{
this.Backstory.skillGainsResolved.Remove(v);
for (int i = 0; i < this.skillGains.Count; ++i)
{
if (this.skillGains[i].DisplayLabel == Util.GetLabel(v))
{
this.skillGains.RemoveAt(i);
break;
}
}
},
getDisplayName = v => Util.GetLabel(v),
};
this.forcedTraitsPlusMinus = new PlusMinusArgs <TraitDef>()
{
allItems = Util.SortedDefList <TraitDef>(),
beingUsed = () => Util.ConvertItems(this.Backstory.forcedTraits, v => v.def),
onAdd = v =>
{
TraitEntry te = new TraitEntry(v, 0);
this.Backstory.forcedTraits.Add(te);
this.forcedTraits.Add(this.CreateTraitEntryInput(te));
this.RemoveDisallowedTraits(v);
},
onRemove = v =>
{
this.RemoveForcedTraits(v);
},
getDisplayName = v => Util.GetLabel(v),
};
this.disallowedTraitsPlusMinus = new PlusMinusArgs <TraitDef>()
{
allItems = Util.SortedDefList <TraitDef>(),
beingUsed = () => Util.ConvertItems(this.Backstory.disallowedTraits, v => v.def),
onAdd = v =>
{
TraitEntry te = new TraitEntry(v, 0);
this.Backstory.disallowedTraits.Add(te);
this.disallowedTraits.Add(this.CreateTraitEntryInput(te));
this.RemoveForcedTraits(v);
},
onRemove = v =>
{
this.RemoveDisallowedTraits(v);
},
getDisplayName = v => Util.GetLabel(v),
};
this.Rebuild();
}
public BiomeWidget(BiomeDef d, DefType type) : base(d, type)
{
if (base.Def.baseWeatherCommonalities == null)
{
base.Def.baseWeatherCommonalities = new List <WeatherCommonalityRecord>();
}
if (base.Def.terrainsByFertility == null)
{
base.Def.terrainsByFertility = new List <TerrainThreshold>();
}
if (base.Def.soundsAmbient == null)
{
base.Def.soundsAmbient = new List <SoundDef>();
}
if (base.Def.terrainPatchMakers == null)
{
base.Def.terrainPatchMakers = new List <TerrainPatchMaker>();
}
if (BiomeDefStats.GetWildAnimals(base.Def) == null)
{
BiomeDefStats.SetWildAnimals(base.Def, new List <BiomeAnimalRecord>());
}
if (BiomeDefStats.GetWildPlants(base.Def) == null)
{
BiomeDefStats.SetWildPlants(base.Def, new List <BiomePlantRecord>());
}
if (BiomeDefStats.GetDiseases(base.Def) == null)
{
BiomeDefStats.SetDiseases(base.Def, new List <BiomeDiseaseRecord>());
}
if (BiomeDefStats.GetAllowedPackAnimals(base.Def) == null)
{
BiomeDefStats.SetAllowedPackAnimals(base.Def, new List <ThingDef>());
}
this.inputWidgets = new List <IInputWidget>()
{
new BoolInputWidget <BiomeDef>(base.Def, "Can Build Base", (BiomeDef def) => def.canBuildBase, (BiomeDef def, bool b) => def.canBuildBase = b),
new BoolInputWidget <BiomeDef>(base.Def, "Can Auto Choose", (BiomeDef def) => def.canAutoChoose, (BiomeDef def, bool b) => def.canAutoChoose = b),
new BoolInputWidget <BiomeDef>(base.Def, "Allow Roads", (BiomeDef def) => def.allowRoads, (BiomeDef def, bool b) => def.allowRoads = b),
new BoolInputWidget <BiomeDef>(base.Def, "Allow Rivers", (BiomeDef def) => def.allowRivers, (BiomeDef def, bool b) => def.allowRivers = b),
new FloatInputWidget <BiomeDef>(base.Def, "Animal Density", (BiomeDef def) => def.animalDensity, (BiomeDef def, float f) => def.animalDensity = f),
new FloatInputWidget <BiomeDef>(base.Def, "Plant Density", (BiomeDef def) => def.plantDensity, (BiomeDef def, float f) => def.plantDensity = f),
new FloatInputWidget <BiomeDef>(base.Def, "Disease Mtb Days", (BiomeDef def) => def.diseaseMtbDays, (BiomeDef def, float f) => def.diseaseMtbDays = f),
new FloatInputWidget <BiomeDef>(base.Def, "Settlement Selection Weight", (BiomeDef def) => def.settlementSelectionWeight, (BiomeDef def, float f) => def.settlementSelectionWeight = f),
new BoolInputWidget <BiomeDef>(base.Def, "Impassable", (BiomeDef def) => def.impassable, (BiomeDef def, bool b) => def.impassable = b),
new BoolInputWidget <BiomeDef>(base.Def, "Has Virtual Plants", (BiomeDef def) => def.hasVirtualPlants, (BiomeDef def, bool b) => def.hasVirtualPlants = b),
new FloatInputWidget <BiomeDef>(base.Def, "Forageability", (BiomeDef def) => def.forageability, (BiomeDef def, float f) => def.forageability = f),
new BoolInputWidget <BiomeDef>(base.Def, "Local Plants Care Fertability", (BiomeDef def) => def.wildPlantsCareAboutLocalFertility, (BiomeDef def, bool b) => def.wildPlantsCareAboutLocalFertility = b),
new FloatInputWidget <BiomeDef>(base.Def, "Wild Plant Regrow Days", (BiomeDef def) => def.wildPlantRegrowDays, (BiomeDef def, float f) => def.wildPlantRegrowDays = f),
new FloatInputWidget <BiomeDef>(base.Def, "Movement Difficulty", (BiomeDef def) => def.movementDifficulty, (BiomeDef def, float f) => def.movementDifficulty = f),
new BoolInputWidget <BiomeDef>(base.Def, "Has Bedrock", (BiomeDef def) => def.hasBedrock, (BiomeDef def, bool b) => def.hasBedrock = b)
};
this.weatherPlusMinusArgs = new PlusMinusArgs <WeatherDef>()
{
allItems = DefDatabase <WeatherDef> .AllDefs,
beingUsed = () => Util.ConvertItems(this.weatherCommonalityRecords, (FloatInputWidget <WeatherCommonalityRecord> w) => w.Parent.weather),
onAdd = delegate(WeatherDef wd)
{
WeatherCommonalityRecord rec = new WeatherCommonalityRecord()
{
weather = wd
};
this.weatherCommonalityRecords.Add(this.CreateWeatherWidget(rec));
base.Def.baseWeatherCommonalities.Add(rec);
},
onRemove = delegate(WeatherDef wd)
{
this.weatherCommonalityRecords.RemoveAll((FloatInputWidget <WeatherCommonalityRecord> w) => w.Parent.weather == wd);
base.Def.baseWeatherCommonalities.RemoveAll((WeatherCommonalityRecord rec) => rec.weather == wd);
},
getDisplayName = (WeatherDef def) => def.label,
};
this.terrainFertilityPlusMinusArgs = new PlusMinusArgs <TerrainDef>()
{
allItems = DefDatabase <TerrainDef> .AllDefs,
beingUsed = () => Util.ConvertItems(this.terrainsByFertility, (MinMaxInputWidget <TerrainThreshold, float> w) => w.Parent.terrain),
onAdd = delegate(TerrainDef td)
{
TerrainThreshold tt = new TerrainThreshold()
{
terrain = td
};
this.terrainsByFertility.Add(this.CreateThresholdWidget(tt));
this.Def.terrainsByFertility.Add(tt);
},
onRemove = delegate(TerrainDef td)
{
this.terrainsByFertility.RemoveAll((MinMaxInputWidget <TerrainThreshold, float> w) => w.Parent.terrain == td);
base.Def.terrainsByFertility.RemoveAll((TerrainThreshold tt) => tt.terrain == td);
},
getDisplayName = (TerrainDef def) => def.label,
};
this.ambientSoundPlusMinusArgs = new PlusMinusArgs <SoundDef>()
{
allItems = DefDatabase <SoundDef> .AllDefs,
beingUsed = () => this.soundsAmbient,
onAdd = delegate(SoundDef sd)
{
this.soundsAmbient.Add(sd);
this.Def.soundsAmbient.Add(sd);
},
onRemove = delegate(SoundDef sd)
{
this.soundsAmbient.Remove(sd);
this.Def.soundsAmbient.Remove(sd);
},
getDisplayName = (SoundDef sd) => sd.defName
};
this.diseasesPlusMinusArgs = new PlusMinusArgs <IncidentDef>()
{
allItems = Util.FindAll(DefDatabase <IncidentDef> .AllDefs, id => id.defName.StartsWith("Disease_")),
beingUsed = () => Util.ConvertItems(this.diseases, (FloatInputWidget <BiomeDiseaseRecord> w) => w.Parent.diseaseInc),
onAdd = delegate(IncidentDef id)
{
BiomeDiseaseRecord r = new BiomeDiseaseRecord()
{
diseaseInc = id, commonality = 0
};
this.diseases.Add(this.CreateDiseaseWidget(r));
BiomeDefStats.GetDiseases(this.Def).Add(r);
},
onRemove = delegate(IncidentDef id)
{
this.diseases.RemoveAll((FloatInputWidget <BiomeDiseaseRecord> w) => w.Parent.diseaseInc == id);
BiomeDefStats.GetDiseases(this.Def).RemoveAll((BiomeDiseaseRecord rec) => rec.diseaseInc == id);
},
getDisplayName = (IncidentDef def) => def.label,
};
this.wildPlantPlusMinusArgs = new PlusMinusArgs <ThingDef>()
{
allItems = Util.FindAll(DefDatabase <ThingDef> .AllDefs, td => td.plant != null),
beingUsed = () => Util.ConvertItems(this.wildPlants, (FloatInputWidget <BiomePlantRecord> w) => w.Parent.plant),
onAdd = delegate(ThingDef td)
{
BiomePlantRecord r = new BiomePlantRecord()
{
plant = td, commonality = 0
};
this.wildPlants.Add(this.CreateWildPlantWidget(r));
BiomeDefStats.GetWildPlants(this.Def).Add(r);
},
onRemove = delegate(ThingDef td)
{
this.wildPlants.RemoveAll((FloatInputWidget <BiomePlantRecord> w) => w.Parent.plant == td);
BiomeDefStats.GetWildPlants(this.Def).RemoveAll((BiomePlantRecord rec) => rec.plant == td);
},
getDisplayName = (ThingDef def) => def.label,
};
this.wildAnimalPlusMinusArgs = new PlusMinusArgs <PawnKindDef>()
{
allItems = Util.FindAll(DefDatabase <PawnKindDef> .AllDefs, pdk => pdk.race.race.thinkTreeMain.defName.Equals("Animal")),
beingUsed = () => Util.ConvertItems(this.wildAnimals, (FloatInputWidget <BiomeAnimalRecord> w) => w.Parent.animal),
onAdd = delegate(PawnKindDef td)
{
BiomeAnimalRecord r = new BiomeAnimalRecord()
{
animal = td, commonality = 0
};
this.wildAnimals.Add(this.CreateWildAnimalWidget(r));
BiomeDefStats.GetWildAnimals(this.Def).Add(r);
},
onRemove = delegate(PawnKindDef td)
{
this.wildAnimals.RemoveAll((FloatInputWidget <BiomeAnimalRecord> w) => w.Parent.animal == td);
BiomeDefStats.GetWildAnimals(this.Def).RemoveAll((BiomeAnimalRecord rec) => rec.animal == td);
},
getDisplayName = (PawnKindDef def) => def.label,
};
this.allowedPackAnimalsPlusMinusArgs = new PlusMinusArgs <ThingDef>()
{
allItems = Util.FindAll(DefDatabase <ThingDef> .AllDefs, td => td.race != null && td.race.herdAnimal),
beingUsed = () => this.allowedPackAnimals,
onAdd = delegate(ThingDef td)
{
this.allowedPackAnimals.Add(td);
BiomeDefStats.GetAllowedPackAnimals(base.Def).Add(td);
},
onRemove = delegate(ThingDef td)
{
this.allowedPackAnimals.Remove(td);
BiomeDefStats.GetAllowedPackAnimals(base.Def).Remove(td);
},
getDisplayName = (ThingDef def) => def.label,
};
this.Rebuild();
}
public ThoughtDefWidget(ThoughtDef def, DefType type) : base(def, type)
{
if (def.requiredTraits == null)
{
def.requiredTraits = new List <TraitDef>();
}
if (def.nullifyingTraits == null)
{
def.nullifyingTraits = new List <TraitDef>();
}
if (def.nullifyingOwnTales == null)
{
def.nullifyingOwnTales = new List <TaleDef>();
}
if (def.stages == null)
{
def.stages = new List <ThoughtStage>();
}
this.stages = new List <ThoughtStageWidget>(def.stages.Count);
this.inputWidgets = new List <IInputWidget>()
{
new IntInputWidget <ThoughtDef>(base.Def, "Stack Limit", d => d.stackLimit, (d, v) => d.stackLimit = v),
new FloatInputWidget <ThoughtDef>(base.Def, "Stacked Effect Multiplier", d => d.stackedEffectMultiplier, (d, v) => d.stackedEffectMultiplier = v),
new FloatInputWidget <ThoughtDef>(base.Def, "Duration (Days)", d => d.durationDays, (d, v) => d.durationDays = v),
new BoolInputWidget <ThoughtDef>(base.Def, "Invert", d => d.invert, (d, v) => d.invert = v),
new BoolInputWidget <ThoughtDef>(base.Def, "Valid While Despawned", d => d.validWhileDespawned, (d, v) => d.validWhileDespawned = v),
new BoolInputWidget <ThoughtDef>(base.Def, "Require Trait Degree", d => d.requiredTraitsDegree != TRAIT_DEGREE_MIN, (d, v) =>
{
if (d.requiredTraitsDegree != TRAIT_DEGREE_MIN)
{
d.requiredTraitsDegree = TRAIT_DEGREE_MIN;
}
else
{
d.requiredTraitsDegree = 0;
}
this.inputWidgets[6].ResetBuffers();
}),
new IntInputWidget <ThoughtDef>(base.Def, "Degree", d => d.requiredTraitsDegree, (d, v) => d.requiredTraitsDegree = v, d => new AInputWidget <ThoughtDef, int> .ShouldDrawInputResult(d.requiredTraitsDegree != TRAIT_DEGREE_MIN)),
new BoolInputWidget <ThoughtDef>(base.Def, "Colonists Only", d => d.nullifiedIfNotColonist, (d, v) => d.nullifiedIfNotColonist = v),
new BoolInputWidget <ThoughtDef>(base.Def, "Show Bubble", d => d.showBubble, (d, v) => d.showBubble = v),
new IntInputWidget <ThoughtDef>(base.Def, "Stack Limit For Other Pawns", d => d.stackLimitForSameOtherPawn, (d, v) => d.stackLimitForSameOtherPawn = v),
new FloatInputWidget <ThoughtDef>(base.Def, "Lerp Opinion To Zero Pct", d => d.lerpOpinionToZeroAfterDurationPct, (d, v) => d.lerpOpinionToZeroAfterDurationPct = v),
new FloatInputWidget <ThoughtDef>(base.Def, "Max Cumulated Opinion Offset", d => d.maxCumulatedOpinionOffset, (d, v) => d.maxCumulatedOpinionOffset = v),
new DefInputWidget <ThoughtDef, ThoughtDef>(base.Def, "Next Thought", 150, d => d.nextThought, (d, v) => d.nextThought = v, true),
new DefInputWidget <ThoughtDef, GameConditionDef>(base.Def, "Game Condition", 150, d => d.gameCondition, (d, v) => d.gameCondition = v, true),
new DefInputWidget <ThoughtDef, TaleDef>(base.Def, "Tale Def", 150, d => d.taleDef, (d, v) => d.taleDef = v, true),
new DefInputWidget <ThoughtDef, HediffDef>(base.Def, "Hediff", 150, d => d.hediff, (d, v) => d.hediff = v, true),
new DefInputWidget <ThoughtDef, StatDef>(base.Def, "Effect Multiply Ing Stat", 200, d => d.effectMultiplyingStat, (d, v) => d.effectMultiplyingStat = v, true),
new DefInputWidget <ThoughtDef, ThoughtDef>(base.Def, "Thought To Make", 200, d => d.thoughtToMake, (d, v) => d.thoughtToMake = v, true),
};
this.nullifyingOwnTales = new PlusMinusArgs <TaleDef>()
{
allItems = DefDatabase <TaleDef> .AllDefs,
beingUsed = () => base.Def.nullifyingOwnTales,
onAdd = v => base.Def.nullifyingOwnTales = Util.AddTo(base.Def.nullifyingOwnTales, v),
onRemove = v => base.Def.nullifyingOwnTales = Util.RemoveFrom(base.Def.nullifyingOwnTales, v),
getDisplayName = v => Util.GetLabel(v)
};
this.requiredTraits = new PlusMinusArgs <TraitDef>()
{
allItems = DefDatabase <TraitDef> .AllDefs,
beingUsed = () => base.Def?.requiredTraits,
onAdd = v =>
{
base.Def.requiredTraits = Util.AddTo(base.Def.requiredTraits, v);
base.Def.nullifyingTraits = Util.RemoveFrom(base.Def.nullifyingTraits, v);
},
onRemove = v => base.Def.requiredTraits = Util.RemoveFrom(base.Def.requiredTraits, v),
getDisplayName = v => Util.GetLabel(v)
};
this.nullifyingTraits = new PlusMinusArgs <TraitDef>()
{
allItems = DefDatabase <TraitDef> .AllDefs,
beingUsed = () => base.Def.nullifyingTraits,
onAdd = v =>
{
base.Def.nullifyingTraits = Util.AddTo(base.Def.nullifyingTraits, v);
base.Def.requiredTraits = Util.RemoveFrom(base.Def.requiredTraits, v);
},
onRemove = v => base.Def.nullifyingTraits = Util.RemoveFrom(base.Def.nullifyingTraits, v),
getDisplayName = v => Util.GetLabel(v)
};
this.Rebuild();
}
public StorytellerCompPropertiesWidget(StorytellerCompProperties p) : base(true, true)
{
if (p.allowedTargetTags == null)
{
p.allowedTargetTags = new List <IncidentTargetTagDef>();
}
if (p.disallowedTargetTags == null)
{
p.disallowedTargetTags = new List <IncidentTargetTagDef>();
}
this.Props = p;
this.label = StorytellerCompPropertiesStats.GetLabel(p);
this.inputWidgets = new List <IInputWidget>()
{
new FloatInputWidget <StorytellerCompProperties>(p, "Min Days Passed", c => c.minDaysPassed, (c, v) => c.minDaysPassed = v),
new FloatInputWidget <StorytellerCompProperties>(p, "Min Inc Chance Pop Intent Factor", c => c.minIncChancePopulationIntentFactor, (c, v) => c.minIncChancePopulationIntentFactor = v),
};
this.allowedTargetTags = new PlusMinusArgs <IncidentTargetTagDef>()
{
allItems = DefDatabase <IncidentTargetTagDef> .AllDefs,
getDisplayName = v => Util.GetLabel(v),
beingUsed = () => this.Props.allowedTargetTags,
onAdd = v =>
{
Util.AddTo(this.Props.allowedTargetTags, v);
Util.RemoveFrom(this.Props.disallowedTargetTags, v);
},
onRemove = v => Util.RemoveFrom(this.Props.allowedTargetTags, v)
};
this.disallowedTargetTags = new PlusMinusArgs <IncidentTargetTagDef>()
{
allItems = DefDatabase <IncidentTargetTagDef> .AllDefs,
getDisplayName = v => Util.GetLabel(v),
beingUsed = () => this.Props.disallowedTargetTags,
onAdd = v =>
{
Util.AddTo(this.Props.disallowedTargetTags, v);
Util.RemoveFrom(this.Props.allowedTargetTags, v);
},
onRemove = v => Util.RemoveFrom(this.Props.disallowedTargetTags, v)
};
switch (p.compClass.FullName)
{
case "RimWorld.StorytellerComp_CategoryIndividualMTBByBiome":
if (p is StorytellerCompProperties_CategoryIndividualMTBByBiome cb)
{
this.inputWidgets.Add(new BoolInputWidget <StorytellerCompProperties_CategoryIndividualMTBByBiome>(
cb, "Apply Caravan Visibility", c => c.applyCaravanVisibility, (c, v) => c.applyCaravanVisibility = v));
}
break;
case "RimWorld.StorytellerComp_CategoryMTB":
if (p is StorytellerCompProperties_CategoryMTB cm)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_CategoryMTB>(
cm, "Mean Time Between (Days)", c => c.mtbDays, (c, v) => c.mtbDays = v));
}
break;
case "RimWorld.StorytellerComp_DeepDrillInfestation":
if (p is StorytellerCompProperties_DeepDrillInfestation cd)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_DeepDrillInfestation>(
cd, "Drill Base Mean Time Between (Days)", c => c.baseMtbDaysPerDrill, (c, v) => c.baseMtbDaysPerDrill = v));
}
break;
case "RimWorld.StorytellerComp_FactionInteraction":
if (p is StorytellerCompProperties_FactionInteraction fi)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_FactionInteraction>(
fi, "Base Incidents Per Year", c => c.baseIncidentsPerYear, (c, v) => c.baseIncidentsPerYear = v));
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_FactionInteraction>(
fi, "Min Spacing Days", c => c.minSpacingDays, (c, v) => c.minSpacingDays = v));
this.inputWidgets.Add(new EnumInputWidget <StorytellerCompProperties_FactionInteraction, StoryDanger>(
fi, "Min Danger", 200, c => c.minDanger, (c, v) => c.minDanger = v));
this.inputWidgets.Add(new BoolInputWidget <StorytellerCompProperties_FactionInteraction>(
fi, "Full Allies Only", c => c.fullAlliesOnly, (c, v) => c.fullAlliesOnly = v));
}
break;
case "RimWorld.StorytellerComp_OnOffCycle":
if (p is StorytellerCompProperties_OnOffCycle ooc)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "On Days", c => c.onDays, (c, v) => c.onDays = v));
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "Off Days", c => c.offDays, (c, v) => c.offDays = v));
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "Min Spacing Days", c => c.minSpacingDays, (c, v) => c.minSpacingDays = v));
// TODO this.inputWidgets.Add(new BoolInputWidget<StorytellerCompProperties_OnOffCycle>(
//ooc, "Apply Raid Beacon Thread Mean Time Between Factor", c => c.applyRaidBeaconThreatMtbFactor, (c, v) => c.applyRaidBeaconThreatMtbFactor = v));
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "Force Raid Enemy Before Days Passed", c => c.forceRaidEnemyBeforeDaysPassed, (c, v) => c.forceRaidEnemyBeforeDaysPassed = v));
this.inputWidgets.Add(new MinMaxInputWidget <StorytellerCompProperties_OnOffCycle, float>(
"Num Incidents range",
new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "Min", c => c.numIncidentsRange.min, (c, v) => c.numIncidentsRange.min = v),
new FloatInputWidget <StorytellerCompProperties_OnOffCycle>(
ooc, "Max", c => c.numIncidentsRange.max, (c, v) => c.numIncidentsRange.max = v)));
}
break;
case "RimWorld.StorytellerComp_RandomMain":
if (p is StorytellerCompProperties_RandomMain rm)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_RandomMain>(
rm, "Mean Time Between (Days)", c => c.mtbDays, (c, v) => c.mtbDays = v));
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_RandomMain>(
rm, "Max Threat Big Interval Days", c => c.maxThreatBigIntervalDays, (c, v) => c.maxThreatBigIntervalDays = v));
this.inputWidgets.Add(new BoolInputWidget <StorytellerCompProperties_RandomMain>(
rm, "Skip Threat Big If Raid Beacon", c => c.skipThreatBigIfRaidBeacon, (c, v) => c.skipThreatBigIfRaidBeacon = v));
this.inputWidgets.Add(new MinMaxInputWidget <StorytellerCompProperties_RandomMain, float>(
"Random Points Factor Range",
new FloatInputWidget <StorytellerCompProperties_RandomMain>(
rm, "Min", c => c.randomPointsFactorRange.min, (c, v) => c.randomPointsFactorRange.min = v),
new FloatInputWidget <StorytellerCompProperties_RandomMain>(
rm, "Max", c => c.randomPointsFactorRange.max, (c, v) => c.randomPointsFactorRange.max = v)));
this.categoryWeightArgs = new PlusMinusArgs <IncidentCategoryDef>()
{
allItems = DefDatabase <IncidentCategoryDef> .AllDefs,
isBeingUsed = d =>
{
foreach (var input in this.categoryWeights)
{
if (input.Parent.category == d)
{
return(true);
}
}
return(false);
},
getDisplayName = d => Util.GetLabel(d),
onAdd = d =>
{
IncidentCategoryEntry ice = new IncidentCategoryEntry()
{
category = d,
weight = 0
};
this.categoryWeights.Add(this.CreateCategoryWeightInput(ice));
((StorytellerCompProperties_RandomMain)this.Props).categoryWeights.Add(ice);
},
onRemove = d =>
{
this.categoryWeights.RemoveAll(v => v.Parent.category == d);
((StorytellerCompProperties_RandomMain)this.Props).categoryWeights.RemoveAll(v => v.category == d);
}
};
}
break;
case "RimWorld.StorytellerComp_SingleMTB":
if (p is StorytellerCompProperties_SingleMTB smtb)
{
this.inputWidgets.Add(new FloatInputWidget <StorytellerCompProperties_SingleMTB>(
smtb, "Mean Time Between (Days)", c => c.mtbDays, (c, v) => c.mtbDays = v));
}
break;
case "RimWorld.StorytellerComp_Triggered":
if (p is StorytellerCompProperties_Triggered t)
{
this.inputWidgets.Add(new IntInputWidget <StorytellerCompProperties_Triggered>(
t, "Delay Ticks", c => c.delayTicks, (c, v) => c.delayTicks = v));
}
break;
}
this.Rebuild();
}
public RecipeWidget(RecipeDef d, DefType type) : base(d, type)
{
if (base.Def.skillRequirements == null)
{
base.Def.skillRequirements = new List <SkillRequirement>();
}
if (base.Def.forceHiddenSpecialFilters == null)
{
base.Def.forceHiddenSpecialFilters = new List <SpecialThingFilterDef>();
}
if (base.Def.recipeUsers == null)
{
base.Def.recipeUsers = new List <ThingDef>();
}
if (base.Def.appliedOnFixedBodyParts == null)
{
base.Def.appliedOnFixedBodyParts = new List <BodyPartDef>();
}
this.inputWidgets = new List <IInputWidget>()
{
new FloatInputWidget <RecipeDef>(base.Def, "Work Amount", (RecipeDef def) => d.workAmount, (RecipeDef def, float f) => d.workAmount = f),
new BoolInputWidget <RecipeDef>(base.Def, "Allow Mixing Ingredients", (RecipeDef def) => d.allowMixingIngredients, (RecipeDef def, bool b) => d.allowMixingIngredients = b),
new BoolInputWidget <RecipeDef>(base.Def, "Auto Strip Corpses", (RecipeDef def) => d.autoStripCorpses, (RecipeDef def, bool b) => d.autoStripCorpses = b),
new BoolInputWidget <RecipeDef>(base.Def, "Product Has Ingredient Stuff", (RecipeDef def) => d.productHasIngredientStuff, (RecipeDef def, bool b) => d.productHasIngredientStuff = b),
new IntInputWidget <RecipeDef>(base.Def, "Target Count Adjustment", (RecipeDef def) => d.targetCountAdjustment, (RecipeDef def, int i) => d.targetCountAdjustment = i),
new FloatInputWidget <RecipeDef>(base.Def, "Work Skill Learn Factor", (RecipeDef def) => d.workSkillLearnFactor, (RecipeDef def, float f) => d.workSkillLearnFactor = f),
new BoolInputWidget <RecipeDef>(base.Def, "Hide Body Part Names", (RecipeDef def) => d.hideBodyPartNames, (RecipeDef def, bool b) => d.hideBodyPartNames = b),
new BoolInputWidget <RecipeDef>(base.Def, "Is Violation", (RecipeDef def) => d.isViolation, (RecipeDef def, bool b) => d.isViolation = b),
new FloatInputWidget <RecipeDef>(base.Def, "Surgery Success Chance Factor", (RecipeDef def) => d.surgerySuccessChanceFactor, (RecipeDef def, float f) => d.surgerySuccessChanceFactor = f),
new FloatInputWidget <RecipeDef>(base.Def, "Death On Failed Surgery Chance", (RecipeDef def) => d.deathOnFailedSurgeryChance, (RecipeDef def, float f) => d.deathOnFailedSurgeryChance = f),
new BoolInputWidget <RecipeDef>(base.Def, "Targets Body Part", (RecipeDef def) => d.targetsBodyPart, (RecipeDef def, bool b) => d.targetsBodyPart = b),
new BoolInputWidget <RecipeDef>(base.Def, "Anesthetize", (RecipeDef def) => d.anesthetize, (RecipeDef def, bool b) => d.anesthetize = b),
new BoolInputWidget <RecipeDef>(base.Def, "Dont Show If Any Ingredient Missing", (RecipeDef def) => d.dontShowIfAnyIngredientMissing, (RecipeDef def, bool b) => d.dontShowIfAnyIngredientMissing = b),
new DefInputWidget <RecipeDef, ResearchProjectDef>(base.Def, "Research Prerequisite", 200, def => def.researchPrerequisite, (def, v) => def.researchPrerequisite = v, true),
new DefInputWidget <RecipeDef, WorkTypeDef>(base.Def, "Required Giver Work Type", 200, def => def.requiredGiverWorkType, (def, v) => def.requiredGiverWorkType = v, true),
new DefInputWidget <RecipeDef, ThingDef>(base.Def, "Unfinished Thing Def", 200, def => def.unfinishedThingDef, (def, v) => def.unfinishedThingDef = v, true),
new DefInputWidget <RecipeDef, SoundDef>(base.Def, "Sound Working", 200, def => def.soundWorking, (def, v) => def.soundWorking = v, true),
new DefInputWidget <RecipeDef, StatDef>(base.Def, "Work Speed Stat", 200, def => def.workSpeedStat, (def, v) => def.workSpeedStat = v, true),
new DefInputWidget <RecipeDef, StatDef>(base.Def, "Efficiency Stat", 200, def => def.efficiencyStat, (def, v) => def.efficiencyStat = v, true),
new DefInputWidget <RecipeDef, StatDef>(base.Def, "Work Table Efficiency Stat", 200, def => def.workTableEfficiencyStat, (def, v) => def.workTableEfficiencyStat = v, true),
new DefInputWidget <RecipeDef, StatDef>(base.Def, "Work Table Speed Stat", 200, def => def.workTableSpeedStat, (def, v) => def.workTableSpeedStat = v, true),
//new DefInputWidget<RecipeDef, HediffDef>(base.Def, "Adds Hediff", 200, def => def.addsHediff, (def, v) => def.addsHediff = v, true),
//new DefInputWidget<RecipeDef, HediffDef>(base.Def, "Removes Hediff", 200, def => def.removesHediff, (def, v) => def.removesHediff = v, true),
new DefInputWidget <RecipeDef, SkillDef>(base.Def, "Work Skill", 200, def => def.workSkill, (def, v) => def.workSkill = v, true),
new DefInputWidget <RecipeDef, EffecterDef>(base.Def, "Effect Working", 200, def => def.effectWorking, (def, v) => def.effectWorking = v, true),
};
this.specialProducts = new PlusMinusArgs <SpecialProductType>()
{
allItems = Enum.GetValues(typeof(SpecialProductType)).OfType <SpecialProductType>().ToList(),
beingUsed = () => base.Def.specialProducts,
onAdd = (spt) => base.Def.specialProducts = Util.AddTo(base.Def.specialProducts, spt),
onRemove = (spt) => base.Def.specialProducts = Util.RemoveFrom(base.Def.specialProducts, spt, true),
getDisplayName = (spt) => spt.ToString()
};
this.forceHiddenSpecialFilters = new PlusMinusArgs <SpecialThingFilterDef>()
{
allItems = DefDatabase <SpecialThingFilterDef> .AllDefs,
beingUsed = () => base.Def.forceHiddenSpecialFilters,
onAdd = (def) => base.Def.forceHiddenSpecialFilters = Util.AddTo(base.Def.forceHiddenSpecialFilters, def),
onRemove = (def) => base.Def.forceHiddenSpecialFilters = Util.RemoveFrom(base.Def.forceHiddenSpecialFilters, def, false),
getDisplayName = (def) => def.label
};
this.recipeUsers = new PlusMinusArgs <ThingDef>()
{
allItems = DefDatabase <ThingDef> .AllDefs,
beingUsed = () => base.Def.recipeUsers,
onAdd = (def) => base.Def.recipeUsers.Add(def),
onRemove = (def) => base.Def.recipeUsers.Remove(def),
getDisplayName = (def) => def.label
};
this.appliedOnFixedBodyParts = new PlusMinusArgs <BodyPartDef>()
{
allItems = DefDatabase <BodyPartDef> .AllDefs,
beingUsed = () => base.Def.appliedOnFixedBodyParts,
onAdd = (def) => base.Def.appliedOnFixedBodyParts = Util.AddTo(base.Def.appliedOnFixedBodyParts, def),
onRemove = (def) => base.Def.appliedOnFixedBodyParts = Util.RemoveFrom(base.Def.appliedOnFixedBodyParts, def, false),
getDisplayName = (def) => def.label
};
this.skillRequirementsPlusMinusArgs = new PlusMinusArgs <SkillDef>()
{
allItems = DefDatabase <SkillDef> .AllDefs,
isBeingUsed = delegate(SkillDef sd)
{
foreach (var v in base.Def.skillRequirements)
{
if (v.skill == sd)
{
return(true);
}
}
return(false);
},
onAdd = delegate(SkillDef sd)
{
SkillRequirement sr = new SkillRequirement()
{
skill = sd, minLevel = 0
};
base.Def.skillRequirements = Util.AddTo(base.Def.skillRequirements, sr);
this.skillRequirements.Add(this.CreateSkillRequirements(sr));
},
onRemove = delegate(SkillDef sd)
{
base.Def.skillRequirements.RemoveAll((sr) => sr.skill == sd);
this.skillRequirements.RemoveAll((sr) => sr.Parent.skill == sd);
},
getDisplayName = (en) => en.ToString()
};
/*this.productsPlusMinusArgs = new PlusMinusArgs<ThingDef>()
* {
* allItems = DefDatabase<ThingDef>.AllDefs,
* isBeingUsed = delegate (ThingDef td)
* {
* foreach (var v in base.Def.products)
* if (v.thingDef == td)
* return true;
* return false;
* },
* onAdd = delegate (ThingDef td)
* {
* ThingDefCountClass tdc = new ThingDefCountClass(td, 0);
* base.Def.products = Util.AddAndCreateIfNeeded(base.Def.products, tdc);
* this.products.Add(this.CreateThingDefCountClass(tdc));
* },
* onRemove = delegate (ThingDef def)
* {
* base.Def.products.RemoveAll((tdc) => tdc.thingDef == def);
* base.Def.products = Util.NullIfNeeded(base.Def.products);
* this.products.RemoveAll((input) => input.Parent.thingDef == def);
* },
* getDisplayName = (en) => en.ToString()
* };*/
this.Rebuild();
}
public TraitWidget(TraitDef def, DefType type) : base(def, type)
{
this.inputWidgets = new List <IInputWidget>()
{
new FloatInputWidget <TraitDef>(base.Def, "Commonality Male", d => TraitDefStat.GetCommonality(d), (d, v) => TraitDefStat.SetCommonality(d, v)),
new FloatInputWidget <TraitDef>(base.Def, "Commonality Female", d => TraitDefStat.GetCommonalityFemale(d), (d, v) => TraitDefStat.SetCommonalityFemale(d, v)),
new BoolInputWidget <TraitDef>(base.Def, "Allow On Hostile", d => d.allowOnHostileSpawn, (d, v) => d.allowOnHostileSpawn = v),
};
var dic = new SortedDictionary <string, WorkTags>();
foreach (var v in Enum.GetValues(typeof(WorkTags)).Cast <WorkTags>())
{
if (v != WorkTags.None)
{
dic.Add(v.ToString(), v);
}
}
this.workTags = new List <WorkTags>(dic.Values);
dic.Clear();
dic = null;
this.requiredWorkTags = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (base.Def.requiredWorkTags & v) == v,
onAdd = v =>
{
base.Def.requiredWorkTags |= v;
base.Def.disabledWorkTags &= ~v;
},
onRemove = v => base.Def.requiredWorkTags &= ~v,
getDisplayName = v => v.ToString()
};
this.disabledWorkTags = new PlusMinusArgs <WorkTags>()
{
allItems = this.workTags,
isBeingUsed = v => (base.Def.disabledWorkTags & v) == v,
onAdd = v =>
{
base.Def.disabledWorkTags |= v;
base.Def.requiredWorkTags &= ~v;
},
onRemove = v => base.Def.disabledWorkTags &= ~v,
getDisplayName = v => v.ToString()
};
this.disabledWorkTypes = new PlusMinusArgs <WorkTypeDef>()
{
allItems = DefDatabase <WorkTypeDef> .AllDefs,
beingUsed = () => base.Def.disabledWorkTypes,
onAdd = v =>
{
base.Def.disabledWorkTypes = Util.AddTo(base.Def.disabledWorkTypes, v);
base.Def.requiredWorkTypes = Util.RemoveFrom(base.Def.requiredWorkTypes, v);
},
onRemove = v => base.Def.disabledWorkTypes = Util.RemoveFrom(base.Def.disabledWorkTypes, v),
getDisplayName = v => Util.GetLabel(v)
};
this.requiredWorkTypes = new PlusMinusArgs <WorkTypeDef>()
{
allItems = DefDatabase <WorkTypeDef> .AllDefs,
beingUsed = () => base.Def.requiredWorkTypes,
onAdd = v =>
{
base.Def.requiredWorkTypes = Util.AddTo(base.Def.requiredWorkTypes, v);
base.Def.disabledWorkTypes = Util.RemoveFrom(base.Def.disabledWorkTypes, v);
},
onRemove = v => base.Def.requiredWorkTypes = Util.RemoveFrom(base.Def.requiredWorkTypes, v),
getDisplayName = v => Util.GetLabel(v)
};
this.conflictingTraits = new PlusMinusArgs <TraitDef>()
{
allItems = DefDatabase <TraitDef> .AllDefs,
beingUsed = () => base.Def.conflictingTraits,
onAdd = v => base.Def.conflictingTraits = Util.AddTo(base.Def.conflictingTraits, v),
onRemove = v => base.Def.conflictingTraits = Util.RemoveFrom(base.Def.conflictingTraits, v),
getDisplayName = v => Util.GetLabel(v)
};
this.Rebuild();
}
