private void DrawTerrainPatchMakers(float x, ref float y, float width)
{
WindowUtil.PlusMinusLabel(x, ref y, width, "Patch Maker",
delegate
{
Find.WindowStack.Add(new Dialog_Name(
"Perlin Frequency",
delegate(string name)
{
TerrainPatchMaker m = new TerrainPatchMaker()
{
perlinFrequency = float.Parse(name)
};
base.Def.terrainPatchMakers.Add(m);
this.terrainPatchMakers.Add(new TerrainPatchMakerWidget(m));
},
delegate(string name)
{
if (!float.TryParse(name, out float freq))
{
return("Must be a number");
}
foreach (var v in base.Def.terrainPatchMakers)
{
if (v.perlinFrequency == freq)
{
return("Perlin Frequency must be unique");
}
}
return(true);
}));
},
public void ApplyStats(TerrainPatchMaker to)
{
to.perlinFrequency = this.perlinFrequency;
to.perlinLacunarity = this.perlinLacunarity;
to.perlinPersistence = this.perlinPersistence;
to.perlinOctaves = this.perlinOctaves;
to.minFertility = this.minFertility;
to.minFertility = this.minFertility;
to.maxFertility = this.maxFertility;
to.minSize = this.minSize;
if (to.thresholds != null)
{
to.thresholds.Clear();
}
if (this.thresholds != null && this.thresholds.Count > 0)
{
if (to.thresholds == null)
{
to.thresholds = new List <TerrainThreshold>(this.thresholds.Count);
}
foreach (var v in this.thresholds)
{
to.thresholds.Add(new TerrainThreshold()
{
terrain = v.Def,
min = v.Min,
max = v.Max
});
}
}
}
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 TerrainPatchMakerStats(TerrainPatchMaker m)
{
this.perlinFrequency = m.perlinFrequency;
this.perlinLacunarity = m.perlinLacunarity;
this.perlinPersistence = m.perlinPersistence;
this.perlinOctaves = m.perlinOctaves;
this.minFertility = m.minFertility;
this.maxFertility = m.maxFertility;
this.minSize = m.minSize;
Util.Populate(out this.thresholds, m.thresholds, v => new MinMaxFloatDefStat <TerrainDef>(v.terrain)
{
Min = v.min, Max = v.max
});
}
public static void ApplyBiomeSettings()
{
Log.Message("[Map Designer] Applying settings");
MapDesignerSettings settings = MapDesignerMod.mod.settings;
// densities
Dictionary <string, BiomeDefault> biomeDefaults = settings.biomeDefaults;
float densityPlant = settings.densityPlant;
float densityAnimal = settings.densityAnimal;
foreach (BiomeDef biome in DefDatabase <BiomeDef> .AllDefs)
{
try
{
biome.animalDensity = biomeDefaults[biome.defName].animalDensity * densityAnimal;
biome.plantDensity = biomeDefaults[biome.defName].plantDensity * densityPlant;
if (biome.plantDensity > 1f)
{
biome.wildPlantRegrowDays = biomeDefaults[biome.defName].wildPlantRegrowDays / biome.plantDensity;
biome.plantDensity = 1f;
}
}
catch
{
Log.Message("[Map Designer] ERROR applying plant and animal settings to " + biome.defName);
}
}
Dictionary <string, FloatRange> densityDefaults = settings.densityDefaults;
// ruins
try
{
float densityRuins = settings.densityRuins;
if (densityRuins > 1)
{
densityRuins = (float)Math.Pow(densityRuins, 3);
}
(DefDatabase <GenStepDef> .GetNamed("ScatterRuinsSimple").genStep as GenStep_Scatterer).countPer10kCellsRange.min = densityDefaults["ScatterRuinsSimple"].min * densityRuins;
(DefDatabase <GenStepDef> .GetNamed("ScatterRuinsSimple").genStep as GenStep_Scatterer).countPer10kCellsRange.max = densityDefaults["ScatterRuinsSimple"].max * densityRuins;
}
catch
{
Log.Message("[Map Designer] ERROR with settings: ruins");
}
// ancient dangers
try
{
float densityDanger = settings.densityDanger;
if (densityDanger > 1)
{
densityDanger = (float)Math.Pow(densityDanger, 4);
}
(DefDatabase <GenStepDef> .GetNamed("ScatterShrines").genStep as GenStep_Scatterer).countPer10kCellsRange.min = densityDefaults["ScatterShrines"].min * densityDanger;
(DefDatabase <GenStepDef> .GetNamed("ScatterShrines").genStep as GenStep_Scatterer).countPer10kCellsRange.max = densityDefaults["ScatterShrines"].max * densityDanger;
}
catch
{
Log.Message("[Map Designer] ERROR with settings: ancient dangers");
}
// geysers
try
{
float densityGeyser = settings.densityGeyser;
if (densityGeyser > 1)
{
densityGeyser = (float)Math.Pow(densityGeyser, 2);
}
(DefDatabase <GenStepDef> .GetNamed("SteamGeysers").genStep as GenStep_Scatterer).countPer10kCellsRange.min = densityDefaults["SteamGeysers"].min * densityGeyser;
(DefDatabase <GenStepDef> .GetNamed("SteamGeysers").genStep as GenStep_Scatterer).countPer10kCellsRange.max = densityDefaults["SteamGeysers"].max * densityGeyser;
}
catch
{
Log.Message("[Map Designer] ERROR with settings: geysers");
}
// rivers
float widthOnMap = 6f;
foreach (RiverDef river in DefDatabase <RiverDef> .AllDefs)
{
try
{
river.widthOnMap *= settings.sizeRiver;
river.widthOnMap = Math.Min(175, river.widthOnMap);
}
catch
{
Log.Message("[Map Designer] ERROR with settings: river width : " + river.defName);
}
}
// terrain
if (Math.Abs(settings.terrainFert - 1f) > 0.05 || Math.Abs(settings.terrainWater - 1f) > 0.05)
{
Log.Message(String.Format("[Map Designer] Terrain settings: fertility: {0} | Water {1}", Math.Round(100 * settings.terrainFert), Math.Round(100 * settings.terrainWater)));
foreach (BiomeDef biome in DefDatabase <BiomeDef> .AllDefs)
{
if (!biome.terrainsByFertility.NullOrEmpty())
{
//Log.Message("Doing adjustments for " + biome.defName);
try
{
TerrainDefault newTerrain;
float minFertBound = -0.2f;
float maxFertBound = 1.2f;
if (ModsConfig.IsActive("BiomesTeam.BiomesCore"))
{
maxFertBound = HelperMethods.GetMaxFertByBiome(biome);
}
newTerrain = TerrainUtility.StretchTerrainFertility(biomeDefaults[biome.defName].terrain, minFertBound, maxFertBound);
biome.terrainsByFertility = newTerrain.terrainsByFertility;
biome.terrainPatchMakers = newTerrain.terrainPatchMakers;
}
catch (Exception e)
{
Log.Message("[Map Designer] ERROR with settings: terrain : " + biome.defName);
Log.Message(e.Message);
TerrainDefault dictEntry = settings.biomeDefaults[biome.defName].terrain;
Log.Message("--terrainsByFertility");
foreach (TerrainThreshold t in dictEntry.terrainsByFertility)
{
Log.Message(String.Format("- {0} .... {1} | {2}", t.terrain.defName, Math.Round(t.min, 2), Math.Round(t.max, 2)));
}
Log.Message("--terrainPatchMakers");
for (int i = 0; i < dictEntry.terrainPatchMakers.Count(); i++)
{
TerrainPatchMaker p = dictEntry.terrainPatchMakers[i];
Log.Message(String.Format("Patchmaker #{0} | min {1} | max {2}", i, p.minFertility, p.maxFertility));
foreach (TerrainThreshold t in p.thresholds)
{
Log.Message(String.Format("--- {0} | {1} | {2}", t.terrain.defName, Math.Round(t.min, 2), Math.Round(t.max, 2)));
}
}
}
}
}
}
else
{
Log.Message("[Map Designer] Terrain settings: Default");
foreach (BiomeDef biome in DefDatabase <BiomeDef> .AllDefs)
{
biome.terrainsByFertility = biomeDefaults[biome.defName].terrain.terrainsByFertility;
biome.terrainPatchMakers = biomeDefaults[biome.defName].terrain.terrainPatchMakers;
}
}
}
public void ApplyStats(object to)
{
if (to is BiomeDef t)
{
t.canBuildBase = this.canBuildBase;
t.canAutoChoose = this.canAutoChoose;
t.allowRoads = this.allowRoads;
t.allowRivers = this.allowRivers;
t.animalDensity = this.animalDensity;
t.plantDensity = this.plantDensity;
t.diseaseMtbDays = this.diseaseMtbDays;
t.settlementSelectionWeight = this.settlementSelectionWeight;
t.impassable = this.impassable;
t.hasVirtualPlants = this.hasVirtualPlants;
t.forageability = this.forageability;
if (this.foragedFood == null)
{
t.foragedFood = null;
}
else
{
t.foragedFood = this.foragedFood.Def;
}
t.wildPlantsCareAboutLocalFertility = this.wildPlantsCareAboutLocalFertility;
t.wildPlantRegrowDays = this.wildPlantRegrowDays;
t.movementDifficulty = this.movementDifficulty;
t.hasBedrock = this.hasBedrock;
if (this.weatherCommonalities != null && t.baseWeatherCommonalities == null)
{
t.baseWeatherCommonalities = new List <WeatherCommonalityRecord>(this.weatherCommonalities.Count);
}
Util.Populate(t.baseWeatherCommonalities, this.weatherCommonalities, delegate(FloatValueDefStat <WeatherDef> s)
{
return(new WeatherCommonalityRecord()
{
weather = s.Def,
commonality = s.value
});
});
if (this.terrainsByFertility != null && t.terrainsByFertility == null)
{
t.terrainsByFertility = new List <TerrainThreshold>(this.terrainsByFertility.Count);
}
Util.Populate(t.terrainsByFertility, this.terrainsByFertility, delegate(MinMaxFloatDefStat <TerrainDef> s)
{
return(new TerrainThreshold
{
terrain = s.Def,
min = s.Min,
max = s.Max
});
});
if (this.soundsAmbient != null && t.soundsAmbient == null)
{
t.soundsAmbient = new List <SoundDef>(this.soundsAmbient.Count);
}
Util.Populate(t.soundsAmbient, this.soundsAmbient, delegate(DefStat <SoundDef> s)
{
return(s.Def);
});
if (this.terrainPatchMakers != null && t.terrainPatchMakers == null)
{
t.terrainPatchMakers = new List <TerrainPatchMaker>(this.terrainPatchMakers.Count);
}
Util.Populate(t.terrainPatchMakers, this.terrainPatchMakers, delegate(TerrainPatchMakerStats s)
{
var v = new TerrainPatchMaker();
s.ApplyStats(v);
return(v);
});
List <BiomePlantRecord> wildPlants = GetWildPlants(base.Def);
if (this.wildPlants != null && wildPlants == null)
{
wildPlants = new List <BiomePlantRecord>(this.wildPlants.Count);
SetWildPlants(base.Def, wildPlants);
}
Util.Populate(wildPlants, this.wildPlants, delegate(FloatValueDefStat <ThingDef> s)
{
return(new BiomePlantRecord()
{
plant = s.Def,
commonality = s.value
});
});
List <BiomeAnimalRecord> wildAnimals = GetWildAnimals(base.Def);
if (this.wildAnimals != null && wildAnimals == null)
{
wildAnimals = new List <BiomeAnimalRecord>(this.wildAnimals.Count);
SetWildAnimals(base.Def, wildAnimals);
}
Util.Populate(wildAnimals, this.wildAnimals, delegate(FloatValueDefStat <PawnKindDef> s)
{
return(new BiomeAnimalRecord()
{
animal = s.Def,
commonality = s.value
});
});
List <BiomeDiseaseRecord> diseases = GetDiseases(base.Def);
if (this.diseases != null && diseases == null)
{
diseases = new List <BiomeDiseaseRecord>(this.diseases.Count);
SetDiseases(base.Def, diseases);
}
Util.Populate(diseases, this.diseases, delegate(FloatValueDoubleDefStat <IncidentDef, BiomeDef> s)
{
return(new BiomeDiseaseRecord()
{
diseaseInc = s.Def,
biome = s.Def2,
commonality = s.value
});
});
List <ThingDef> allowedPackAnimals = GetAllowedPackAnimals(base.Def);
if (this.allowedPackAnimals != null && allowedPackAnimals == null)
{
allowedPackAnimals = new List <ThingDef>(this.allowedPackAnimals.Count);
SetAllowedPackAnimals(base.Def, allowedPackAnimals);
}
Util.Populate(allowedPackAnimals, this.allowedPackAnimals, delegate(DefStat <PawnKindDef> s)
{
return(s.Def.race);
});
}
else
{
Log.Error("ThingDefStat passed none ThingDef!");
}
}
public static TerrainDefault StretchTerrainFertility(TerrainDefault old, float min, float max)
{
oldTerrain = old;
minMapFert = min;
maxMapFert = max;
newTerrain = new TerrainDefault();
newTerrain.terrainsByFertility = new List <TerrainThreshold>(oldTerrain.terrainsByFertility);
newTerrain.terrainPatchMakers = new List <TerrainPatchMaker>();
for (int i = 0; i < oldTerrain.terrainPatchMakers.Count(); i++)
{
TerrainPatchMaker p = new TerrainPatchMaker();
p.maxFertility = oldTerrain.terrainPatchMakers[i].maxFertility;
p.minFertility = oldTerrain.terrainPatchMakers[i].minFertility;
p.perlinFrequency = oldTerrain.terrainPatchMakers[i].perlinFrequency;
p.perlinLacunarity = oldTerrain.terrainPatchMakers[i].perlinLacunarity;
p.perlinOctaves = oldTerrain.terrainPatchMakers[i].perlinOctaves;
p.perlinPersistence = oldTerrain.terrainPatchMakers[i].perlinPersistence;
p.thresholds = new List <TerrainThreshold>(oldTerrain.terrainPatchMakers[i].thresholds);
newTerrain.terrainPatchMakers.Add(p);
}
List <TerrainThreshold> oldTerrainsByFertility = oldTerrain.terrainsByFertility;
List <TBF> listTbf = new List <TBF>();
// convert to TBFs
for (int i = 0; i < oldTerrainsByFertility.Count(); i++)
{
TBF item = new TBF()
{
thresh = oldTerrainsByFertility[i],
size = Math.Min(oldTerrainsByFertility[i].max, maxMapFert) - Math.Max(oldTerrainsByFertility[i].min, minMapFert)
};
listTbf.Add(item);
}
// the actual adjustments
if (listTbf.Count() >= 1)
{
FertChangeTbf(listTbf);
}
// TerrainPatchMaker adjustments
List <TerrainDef> patchTerrains = new List <TerrainDef>();
foreach (TerrainPatchMaker p in newTerrain.terrainPatchMakers)
{
foreach (TerrainThreshold t in p.thresholds)
{
patchTerrains.Add(t.terrain);
}
}
// check that there are terrains
if (patchTerrains.Count() >= 1)
{
FertChangePatchMakers(patchTerrains);
}
return(newTerrain);
}
private static void FertChangePatchMakers(List <TerrainDef> patchTerrains)
{
MapDesignerSettings settings = MapDesignerMod.mod.settings;
float minAllowable = -1.5f;
float maxAllowable = 1.5f;
// find highest fert terrain overall
patchTerrains.Sort((x, y) => x.fertility.CompareTo(y.fertility));
float maxFert = patchTerrains.Max(t => t.fertility);
for (int index = 0; index < newTerrain.terrainPatchMakers.Count; index++)
{
TerrainPatchMaker p = newTerrain.terrainPatchMakers[index];
// sort terrains by min
p.thresholds.Sort((x, y) => x.min.CompareTo(y.min));
// Make new list:
List <TBF> listTbf = new List <TBF>();
float current = -999f;
for (int i = 0; i < p.thresholds.Count; i++)
{
// if current == terrain min, add terrain to list
// set current = terrain max
// if terrain is the minFert or maxFert, change size appropriately
TBF tbf = new TBF();
TBF placeholder = new TBF();
if (!Mathf.Approximately(current, p.thresholds[i].min))
{
//placeholder when needed
placeholder.size = Math.Min(p.thresholds[i].min, maxAllowable) - Math.Max(current, minAllowable);
current = p.thresholds[i].min;
listTbf.Add(placeholder);
}
// real thing
current = p.thresholds[i].max;
tbf.thresh = p.thresholds[i];
tbf.size = Math.Min(p.thresholds[i].max, maxAllowable) - Math.Max(p.thresholds[i].min, minAllowable);
if (tbf.thresh.terrain.fertility == maxFert)
{
tbf.size *= settings.terrainFert;
}
if (tbf.thresh.terrain.IsWater)
{
tbf.size *= settings.terrainWater;
}
else if (settings.flagTerrainWater && !tbf.thresh.terrain.affordances.Contains(TerrainAffordanceDefOf.Heavy))
{
tbf.size *= settings.terrainWater;
}
listTbf.Add(tbf);
}
// add extra placeholder at end if needed
if (current < maxAllowable)
{
listTbf.Add(new TBF()
{
size = maxAllowable - current
});
}
newTerrain.terrainPatchMakers[index].thresholds = SquishTerrain(listTbf, minAllowable, maxAllowable);
}
}