public void StartTrade()
{
var info = StockGenerator.GenerateInfo();
WriteMessage($"\nCompany: {info.Company}, Price: {info.Price}");
Notify(info);
}
public void StartTrade()
{
var info = StockGenerator.GenerateInfo();
WriteMessage($"\nCompany: {info.Company}, Price: {info.Price}");
_handler?.Invoke(info);
}
public static void Scaled(ref int __result, StockGenerator __instance)
{
//TradeScalar tradeScalar = new TradeScalar();
//var placeholder = __instance.trader.defName;
if (__instance.trader.orbital || __instance.trader.defName.Contains("Base_"))
{
int random = UnityEngine.Random.Range(-3, 3);
int wealthTotal = Mathf.RoundToInt(Find.VisibleMap.wealthWatcher.WealthTotal); //Uses Verse.Find to get colony wealth, rounded to an integer.
float tradeLoss = (1f - Find.Storyteller.difficulty.tradePriceFactorLoss); //Finds the tradePriceFactorLoss. Value is 1, 0.95, 0.9, 0.85, or 0.8
__result = random + Mathf.RoundToInt((float)Math.Log(Math.E + (wealthTotal * tradeLoss)) * __result); //Minimum value of scalar is 1 when wealthTotal = 0
}
}
public static void Scaled(ref int __result, StockGenerator __instance)
{
if (!__instance.trader.orbital && !__instance.trader.defName.Contains("Base_"))
{
return;
}
var random = UnityEngine.Random.Range(-3, 3);
// Uses Verse.Find to get colony wealth.
var wealthTotal = Find.VisibleMap.wealthWatcher.WealthTotal;
// Finds the tradePriceFactorLoss. Value is 1, 0.95, 0.9, 0.85, or 0.8
var tradeLoss = (1 - Find.Storyteller.difficulty.tradePriceFactorLoss);
// Minimum value of scalar is 1 when wealthTotal = 0
__result = random + (int)Math.Round(Math.Log(Math.E + (wealthTotal * tradeLoss)) * __result);
}
static void Postfix(ref int __result, StockGenerator __instance)
{
float adjustment = Settings.ScaleAdjustment * 0.0008f;
float totalWealth = Find.World.PlayerWealthForStoryteller;
float storyTellerPriceLossFactor = 1f - Find.Storyteller.difficulty.tradePriceFactorLoss;
if (Settings.ScaleVisitors || __instance.trader.orbital || __instance.trader.defName.Contains("Base_"))
{
double log = Math.Log(2.7182818284590451 + totalWealth * storyTellerPriceLossFactor);
if (Settings.IncludeLogging)
{
Log.Message(" __result pre: " + __result);
}
__result = (int)(adjustment * log * __result);
if (Settings.IncludeLogging)
{
Log.Message(" __result post: " + __result);
Log.Message("");
}
}
}
static RemoveModernStuff()
{
DebugString.AppendLine("Lord of the Rings - The Third Age - Start Removal Log");
DebugString.AppendLine("Tech Limiter Active: Max Level = " + MAX_TECHLEVEL.ToString());
giveApproppriateTechLevels();
removedDefs = 0;
IEnumerable <ResearchProjectDef> projects =
DefDatabase <ResearchProjectDef> .AllDefs.Where(rpd => rpd.techLevel > MAX_TECHLEVEL);
things = new HashSet <ThingDef>(DefDatabase <ThingDef> .AllDefs.Where(td =>
td.techLevel > MAX_TECHLEVEL ||
(td.researchPrerequisites?.Any(rpd => projects.Contains(rpd)) ?? false) || new[]
{
"Gun_Revolver", "VanometricPowerCell", "PsychicEmanator", "InfiniteChemreactor", "Joywire",
"Painstopper"
}.Contains(td.defName)));
DebugString.AppendLine("RecipeDef Removal List");
var recipeDefsToRemove = DefDatabase <RecipeDef> .AllDefs.Where(rd =>
rd.products.Any(tcc => things.Contains(tcc.thingDef)) ||
rd.AllRecipeUsers.All(td => things.Contains(td)) ||
projects.Contains(rd.researchPrerequisite)).Cast <Def>().ToList();
recipeDefsToRemove?.RemoveAll(x =>
x.defName == "ExtractMetalFromSlag" ||
x.defName == "SmeltWeapon" ||
x.defName == "DestroyWeapon" ||
x.defName == "OfferingOfPlants_Meagre" ||
x.defName == "OfferingOfPlants_Decent" ||
x.defName == "OfferingOfPlants_Sizable" ||
x.defName == "OfferingOfPlants_Worthy" ||
x.defName == "OfferingOfPlants_Impressive" ||
x.defName == "OfferingOfMeat_Meagre" ||
x.defName == "OfferingOfMeat_Decent" ||
x.defName == "OfferingOfMeat_Sizable" ||
x.defName == "OfferingOfMeat_Worthy" ||
x.defName == "OfferingOfMeat_Impressive" ||
x.defName == "OfferingOfMeals_Meagre" ||
x.defName == "OfferingOfMeals_Decent" ||
x.defName == "OfferingOfMeals_Sizable" ||
x.defName == "OfferingOfMeals_Worthy" ||
x.defName == "OfferingOfMeals_Impressive" ||
x.defName == "ROMV_ExtractBloodVial" ||
x.defName == "ROMV_ExtractBloodPack"
);
RemoveStuffFromDatabase(typeof(DefDatabase <RecipeDef>), recipeDefsToRemove);
DebugString.AppendLine("ResearchProjectDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <ResearchProjectDef>), projects.Cast <Def>());
DebugString.AppendLine("Scenario Part Removal List");
FieldInfo getThingInfo =
typeof(ScenPart_ThingCount).GetField("thingDef", BindingFlags.NonPublic | BindingFlags.Instance);
foreach (ScenarioDef def in DefDatabase <ScenarioDef> .AllDefs)
{
foreach (ScenPart sp in def.scenario.AllParts)
{
if (sp is ScenPart_ThingCount && things.Contains((ThingDef)getThingInfo?.GetValue(sp)))
{
def.scenario.RemovePart(sp);
DebugString.AppendLine("- " + sp.Label + " " + ((ThingDef)getThingInfo?.GetValue(sp)).label +
" from " + def.label);
}
}
}
foreach (ThingCategoryDef thingCategoryDef in DefDatabase <ThingCategoryDef> .AllDefs)
{
thingCategoryDef.childThingDefs.RemoveAll(things.Contains);
}
DebugString.AppendLine("Stock Generator Part Cleanup");
foreach (TraderKindDef tkd in DefDatabase <TraderKindDef> .AllDefs)
{
for (int i = tkd.stockGenerators.Count - 1; i >= 0; i--)
{
StockGenerator stockGenerator = tkd.stockGenerators[i];
switch (stockGenerator)
{
case StockGenerator_SingleDef sd when things.Contains(Traverse.Create(sd).Field("thingDef")
.GetValue <ThingDef>()):
ThingDef def = Traverse.Create(sd).Field("thingDef")
.GetValue <ThingDef>();
tkd.stockGenerators.Remove(stockGenerator);
DebugString.AppendLine("- " + def.label + " from " + tkd.label +
"'s StockGenerator_SingleDef");
break;
case StockGenerator_MultiDef md:
Traverse thingListTraverse = Traverse.Create(md).Field("thingDefs");
List <ThingDef> thingList = thingListTraverse.GetValue <List <ThingDef> >();
var removeList = thingList.FindAll(things.Contains);
removeList?.ForEach(x =>
DebugString.AppendLine("- " + x.label + " from " + tkd.label +
"'s StockGenerator_MultiDef"));
thingList.RemoveAll(things.Contains);
if (thingList.NullOrEmpty())
{
tkd.stockGenerators.Remove(stockGenerator);
}
else
{
thingListTraverse.SetValue(thingList);
}
break;
}
}
}
DebugString.AppendLine("IncidentDef Removal List");
IEnumerable <IncidentDef> incidents = DefDatabase <IncidentDef> .AllDefs
.Where(id => new[]
{
typeof
(IncidentWorker_ShipChunkDrop
),
AccessTools
.TypeByName(
"IncidentWorker_ShipPartCrash"),
typeof
(IncidentWorker_QuestJourneyOffer
),
typeof
(IncidentWorker_ResourcePodCrash
),
//typeof(IncidentWorker_RefugeePodCrash),
typeof(IncidentWorker_TransportPodCrash),
typeof
(IncidentWorker_PsychicDrone
),
typeof
(IncidentWorker_RansomDemand
),
typeof
(IncidentWorker_ShortCircuit
),
typeof
(IncidentWorker_OrbitalTraderArrival
),
typeof
(IncidentWorker_PsychicSoothe
)
}.SelectMany(
it =>
it
.AllSubclassesNonAbstract()
.Concat(
it))
.ToArray()
.Contains(
id
.workerClass) ||
new[]
{
"Disease_FibrousMechanites",
"Disease_SensoryMechanites",
"RaidEnemyEscapeShip",
"StrangerInBlackJoin"
}.Contains(
id
.defName)).ToList();
foreach (IncidentDef incident in incidents)
{
incident.targetTags?.Clear();
incident.baseChance = 0f;
incident.allowedBiomes?.Clear();
incident.earliestDay = int.MaxValue;
}
RemoveStuffFromDatabase(typeof(DefDatabase <IncidentDef>), incidents.Cast <Def>());
DebugString.AppendLine("Replaced Ancient Asphalt Road / Ancient Asphalt Highway with Stone Road");
RoadDef[] targetRoads = { RoadDefOf.AncientAsphaltRoad, RoadDefOf.AncientAsphaltHighway };
RoadDef originalRoad = DefDatabase <RoadDef> .GetNamed("StoneRoad");
List <string> fieldNames = AccessTools.GetFieldNames(typeof(RoadDef));
fieldNames.Remove("defName");
foreach (FieldInfo fi in fieldNames.Select(name => AccessTools.Field(typeof(RoadDef), name)))
{
object fieldValue = fi.GetValue(originalRoad);
foreach (RoadDef targetRoad in targetRoads)
{
fi.SetValue(targetRoad, fieldValue);
}
}
DebugString.AppendLine("Special Hediff Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <HediffDef>), (hediffs = new[] { HediffDefOf.Gunshot }).Cast <Def>());
DebugString.AppendLine("RaidStrategyDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <RaidStrategyDef>),
DefDatabase <RaidStrategyDef> .AllDefs
.Where(rs => typeof(ScenPart_ThingCount).IsAssignableFrom(rs.workerClass)).Cast <Def>());
// ItemCollectionGeneratorUtility.allGeneratableItems.RemoveAll(match: things.Contains);
//
// foreach (Type type in typeof(ItemCollectionGenerator_Standard).AllSubclassesNonAbstract())
// type.GetMethod(name: "Reset")?.Invoke(obj: null, parameters: null);
DebugString.AppendLine("ThingDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <ThingDef>), things.ToArray());
DebugString.AppendLine("ThingSetMaker Reset");
ThingSetMakerUtility.Reset();
DebugString.AppendLine("TraitDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <TraitDef>),
// { nameof(TraitDefOf.Prosthophobe), "Prosthophile" } ?
DefDatabase <TraitDef> .AllDefs
.Where(td => new[] { nameof(TraitDefOf.BodyPurist), "Transhumanist" }.Contains(td.defName))
.Cast <Def>());
DebugString.AppendLine("Designators Resolved Again");
MethodInfo resolveDesignatorsAgain = typeof(DesignationCategoryDef).GetMethod("ResolveDesignators",
BindingFlags.NonPublic | BindingFlags.Instance);
foreach (DesignationCategoryDef dcd in DefDatabase <DesignationCategoryDef> .AllDefs)
{
resolveDesignatorsAgain?.Invoke(dcd, null);
}
DebugString.AppendLine("PawnKindDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <PawnKindDef>),
DefDatabase <PawnKindDef> .AllDefs
.Where(pkd =>
(!pkd.defaultFactionType?.isPlayer ?? false) &&
(pkd.race.techLevel > MAX_TECHLEVEL || pkd.defaultFactionType?.techLevel > MAX_TECHLEVEL) &&
!pkd.defName.EqualsIgnoreCase("Villager") && !pkd.defName.EqualsIgnoreCase("SpaceRefugee"))
.Cast <Def>());
DebugString.AppendLine("FactionDef Removal List");
RemoveStuffFromDatabase(typeof(DefDatabase <FactionDef>),
DefDatabase <FactionDef> .AllDefs.Where(fd => !fd.isPlayer && fd.techLevel > MAX_TECHLEVEL).Cast <Def>());
DebugString.AppendLine("BackstoryDef Removal List");
BackstoryHandler.RemoveIncompatibleBackstories(DebugString);
DebugString.AppendLine("MapGeneratorDef Removal List");
DebugString.AppendLine("- GenStep_SleepingMechanoids");
DebugString.AppendLine("- GenStep_Turrets");
DebugString.AppendLine("- GenStep_Power");
foreach (MapGeneratorDef mgd in DefDatabase <MapGeneratorDef> .AllDefs)
{
mgd.genSteps.RemoveAll(gs =>
gs.genStep is GenStep_SleepingMechanoids || gs.genStep is GenStep_Turrets ||
gs.genStep is GenStep_Power);
}
DebugString.AppendLine("RuleDef Removal List");
DebugString.AppendLine("- SymbolResolver_AncientCryptosleepCasket");
DebugString.AppendLine("- SymbolResolver_ChargeBatteries");
DebugString.AppendLine("- SymbolResolver_EdgeMannedMortor");
DebugString.AppendLine("- SymbolResolver_FirefoamPopper");
DebugString.AppendLine("- SymbolResolver_MannedMortar");
DebugString.AppendLine("- SymbolResolver_");
foreach (RuleDef rd in DefDatabase <RuleDef> .AllDefs)
{
rd.resolvers.RemoveAll(sr =>
sr is SymbolResolver_AncientCryptosleepCasket || sr is SymbolResolver_ChargeBatteries ||
sr is SymbolResolver_EdgeMannedMortar || sr is SymbolResolver_FirefoamPopper ||
sr is SymbolResolver_MannedMortar || sr is SymbolResolver_OutdoorLighting);
if (rd.resolvers.Count == 0)
{
rd.resolvers.Add(new SymbolResolver_AddWortToFermentingBarrels());
}
}
Log.Message("Removed " + removedDefs + " modern defs");
PawnWeaponGenerator.Reset();
PawnApparelGenerator.Reset();
Debug.Log(DebugString.ToString());
DebugString = new StringBuilder();
}
public ColonyStockGenerator(StockGenerator parent)
{
this.parent = parent;
}
private static void RenderStockGenerator(StockGenerator gen)
{
CONS.WriteLine($" Class: {gen.Class.ToStringOrDefault()}");
if (gen.TradeTag != null)
{
CONS.WriteLine($" tradeTag: {gen.TradeTag}");
}
if ((gen.TradeTags?.Any()).GetValueOrDefault())
{
CONS.WriteLine(" tradeTags:");
foreach (var tag in gen.TradeTags)
{
CONS.WriteLine($" li: {tag.ToStringOrDefault()}");
}
}
if (gen.CategoryDef != null)
{
CONS.WriteLine($" categoryDef: {gen.CategoryDef}");
}
if (gen.ThingDef != null)
{
CONS.WriteLine($" thingDef: {gen.ThingDef}");
}
if ((gen.ThingDefs?.Any()).GetValueOrDefault())
{
CONS.WriteLine(" thingDefs:");
foreach (var def in gen.ThingDefs)
{
CONS.WriteLine($" li: {def.ToStringOrDefault()}");
}
}
if (gen.CountRange != null)
{
CONS.WriteLine($" countRange: {gen.CountRange.ToRenderString()}");
}
if (gen.ThingDefCountRange != null)
{
CONS.WriteLine($" thingDefCountRange: {gen.ThingDefCountRange.ToRenderString()}");
}
if (gen.KindCountRange != null)
{
CONS.WriteLine($" kindCountRange: {gen.KindCountRange.ToRenderString()}");
}
if (gen.Price != null)
{
CONS.WriteLine($" price: {gen.Price}");
}
if (gen.TotalPriceRange != null)
{
CONS.WriteLine($" totalPriceRange: {gen.TotalPriceRange.ToRenderString()}");
}
if (gen.MaxTechLevelGenerate != null)
{
CONS.WriteLine($" maxTechLevelGenerate: {gen.MaxTechLevelGenerate}");
}
if (gen.CheckTemperature.HasValue)
{
CONS.WriteLine($" checkTemperature: {gen.CheckTemperature.Value}");
}
if (gen.MaxWildness.HasValue)
{
CONS.WriteLine($" maxWildness: {gen.MaxWildness.Value}");
}
}
private IEnumerable <Thing> GenerateTraderThings(TraderKindDef traderDef)
{
bool flag = false;
List <StockGenerator> .Enumerator enumerator = traderDef.stockGenerators.GetEnumerator();
while (enumerator.MoveNext())
{
StockGenerator currentGenerator = enumerator.Current;
IEnumerator <Thing> generatedThings = currentGenerator.GenerateThings().GetEnumerator();
try
{
while (generatedThings.MoveNext())
{
Thing generatedThing = generatedThings.Current;
if (!(currentGenerator is StockGenerator_Treasures) &&
generatedThing.def.tradeability != Tradeability.Stockable)
{
Log.Error(string.Concat(new object[]
{
traderDef,
" generated carrying ",
generatedThing,
" which has is not Stockable. Ignoring..."
}));
}
else
{
CompQuality compQuality = generatedThing.TryGetComp <CompQuality>();
if (compQuality != null)
{
compQuality.SetQuality(QualityUtility.RandomTraderItemQuality(),
ArtGenerationContext.Outsider);
}
if (generatedThing.def.colorGeneratorInTraderStock != null)
{
var color = generatedThing.def.colorGeneratorInTraderStock.NewRandomizedColor();
generatedThing.SetColor(color, true);
}
if (generatedThing.def.Minifiable)
{
int stackCount = generatedThing.stackCount;
generatedThing.stackCount = 1;
MinifiedThing minifiedThing = generatedThing.MakeMinified();
minifiedThing.stackCount = stackCount;
generatedThing = minifiedThing;
}
flag = true;
yield return(generatedThing);
}
}
}
finally
{
if (!flag)
{
if (generatedThings != null)
{
generatedThings.Dispose();
}
}
}
}
yield break;
}
