public static Pawn FindBestNegotiator(Caravan caravan, Faction negotiatingWith = null, TraderKindDef trader = null)
{
Predicate <Pawn> pawnValidator = null;
if (negotiatingWith != null)
{
pawnValidator = (Pawn p) => p.CanTradeWith(negotiatingWith, trader);
}
return(FindPawnWithBestStat(caravan, StatDefOf.TradePriceImprovement, pawnValidator));
}
public Job_CallTradeShip(JobDef jobDef, LocalTargetInfo targetA, TraderKindDef traderKindDef, TraderKindEnum traderKind) : base(jobDef, targetA)
{
this.TraderKindDef = traderKindDef;
this.TraderKind = traderKind;
}
/// <summary>
/// Find best negotiator in VehicleCaravan for trading on the World Map
/// </summary>
/// <param name="vehicle"></param>
/// <param name="faction"></param>
/// <param name="trader"></param>
public static Pawn FindBestNegotiator(VehiclePawn vehicle, Faction faction = null, TraderKindDef trader = null)
{
Predicate <Pawn> pawnValidator = null;
if (faction != null)
{
pawnValidator = ((Pawn p) => p.CanTradeWith(faction, trader));
}
return(vehicle.FindPawnWithBestStat(StatDefOf.TradePriceImprovement, pawnValidator));
}
// Token: 0x0600000D RID: 13 RVA: 0x00002113 File Offset: 0x00000313
public override void PostPostGeneratedForTrader(TraderKindDef trader, int forTile, Faction forFaction)
{
this.SetQuality(QualityCategory.Normal, ArtGenerationContext.Outsider);
}
protected override void GeneratePawns(PawnGroupMakerParms parms, PawnGroupMaker groupMaker, List <Pawn> outPawns, bool errorOnZeroResults = true)
{
genderValidator = null;
// Validation steps
if (!CanGenerateFrom(parms, groupMaker) || !ValidateTradersList(groupMaker) || !ValidateCarriers(groupMaker))
{
if (errorOnZeroResults)
{
Log.Error("Cannot generate carnival caravan for " + parms.faction + ". parms=" + parms);
}
return;
}
// End validation steps
// Restrict gender of entertainers if it is in the name
if (parms.faction.Name.EndsWith("Boys"))
{
genderValidator = delegate(Pawn p)
{
return(p.Is(CarnivalRole.Entertainer, false) && p.gender == Gender.Male);
};
}
else if (parms.faction.Name.EndsWith("Girls") ||
parms.faction.Name.EndsWith("Gals"))
{
genderValidator = delegate(Pawn p)
{
return(p.Is(CarnivalRole.Entertainer, false) && p.gender == Gender.Female);
};
}
// New approach
// Spawn manager (costless)
outPawns.Add(parms.faction.leader);
// Generate vendors (first is costless)
var allWares = new List <Thing>();
int numCarnies = 0;
int maxVendors = Mathf.Clamp(groupMaker.traders.First().selectionWeight, 1, MaxVendors);
for (int i = 0; i < maxVendors; i++)
{
TraderKindDef traderKind = null;
int t = i % 3;
switch (t)
{
case 0:
traderKind = _DefOf.Carn_Trader_Food;
break;
case 1:
traderKind = _DefOf.Carn_Trader_Surplus;
break;
case 2:
traderKind = _DefOf.Carn_Trader_Curios;
break;
default:
traderKind = _DefOf.Carn_Trader_Food;
Log.Error("PawnGroupKindWorker_Carnival reached a bad place in code.");
break;
}
// Subtracts points, first costless:
var vendor = GenerateVendor(parms, groupMaker, traderKind, i > 0);
if (vendor != null)
{
outPawns.Add(vendor);
numCarnies++;
}
else
{
break;
}
// Generate wares
var waresParms = default(ItemCollectionGeneratorParams);
waresParms.traderDef = traderKind;
waresParms.forTile = parms.tile;
waresParms.forFaction = parms.faction;
waresParms.validator = delegate(ThingDef def)
{
if (def.stackLimit > 1)
{
return(def.statBases.GetStatValueFromList(StatDefOf.Mass, 1f) * (def.stackLimit / 3f) < 68f);
}
else
{
return(def.statBases.GetStatValueFromList(StatDefOf.Mass, 1f) < 68f);
}
};
allWares.AddRange(ItemCollectionGeneratorDefOf.TraderStock.Worker.Generate(waresParms));
// Generate guards for each trader
foreach (var guard in GenerateGroup(parms, groupMaker.guards, i > 0))
{
outPawns.Add(guard);
}
// Generate carnies for each trader
foreach (var carny in GenerateGroup(parms, groupMaker.options, i > 0))
{
if (numCarnies++ > MaxCarnies)
{
break;
}
outPawns.Add(carny);
}
}
// Spawn pawns that are for sale (if any)
foreach (Pawn sellable in GetPawnsFromWares(parms, allWares))
{
outPawns.Add(sellable);
}
// Generate carriers
outPawns.AddRange(
GenerateCarriers(parms, groupMaker, allWares) // carriers w/ traders' wares
.Concat(GenerateCarriers(parms, groupMaker, null)) // carrier w/ 100 silver
);
}
public virtual void PostPostGeneratedForTrader(TraderKindDef trader, int forTile, Faction forFaction)
{
}
/// <summary>
/// Change quality carried by traders depending on Faction/Goodwill/Wealth.
/// </summary>
/// <returns>QualityCategory depending on wealth or goodwill. Fallsback to vanilla when fails.</returns>
private static QualityCategory FactionAndGoodWillDependantQuality(Faction faction, Map map, TraderKindDef trader)
{
if ((trader.orbital || trader.defName.Contains(value: "_Base")) && map != null)
{
if (Rand.Value < 0.25f)
{
return(QualityCategory.Normal);
}
float num = Rand.Gaussian(centerX: WealthQualityDeterminationCurve.Evaluate(x: map.wealthWatcher.WealthTotal), widthFactor: WealthQualitySpreadDeterminationCurve.Evaluate(x: map.wealthWatcher.WealthTotal));
num = Mathf.Clamp(value: num, min: 0f, max: QualityUtility.AllQualityCategories.Count - 0.5f);
return((QualityCategory)((int)num));
}
if (map != null && faction != null)
{
float qualityIncreaseFromTimesTradedWithFaction = Mathf.Clamp01(value: (float)map.GetComponent <MapComponent_GoodWillTrader>().TimesTraded[key: faction] / 100);
float qualityIncreaseFactorFromPlayerGoodWill = Mathf.Clamp01(value: (float)faction.GoodwillWith(other: Faction.OfPlayer) / 100);
if (Rand.Value < 0.25f)
{
return(QualityCategory.Normal);
}
float num = Rand.Gaussian(centerX: 2.5f + qualityIncreaseFactorFromPlayerGoodWill, widthFactor: 0.84f + qualityIncreaseFromTimesTradedWithFaction);
num = Mathf.Clamp(value: num, min: 0f, max: QualityUtility.AllQualityCategories.Count - 0.5f);
return((QualityCategory)((int)num));
}
return(QualityUtility.GenerateQualityTraderItem());
}
static bool Prefix(ref PawnGroupKindWorker_Trader __instance, ref Pawn __result, PawnGroupMakerParms parms, PawnGroupMaker groupMaker, TraderKindDef traderKind)
{
if (parms.faction == FactionColonies.getPlayerColonyFaction())
{
List <PawnKindDef> list = new List <PawnKindDef>();
foreach (ThingDef def in Find.World.GetComponent <FactionFC>().raceFilter.AllowedThingDefs)
{
list.Add(def.race.AnyPawnKind);
}
Pawn pawn = PawnGenerator.GeneratePawn(new PawnGenerationRequest(list.RandomElement(), parms.faction, PawnGenerationContext.NonPlayer, parms.tile, false, false, false, false, true, false, 1f, false, true, true, true, parms.inhabitants, false, false, false, 0f, null, 1f, null, null, null, null, null, null, null, null, null, null, null, null));
pawn.mindState.wantsToTradeWithColony = true;
PawnComponentsUtility.AddAndRemoveDynamicComponents(pawn, true);
pawn.trader.traderKind = traderKind;
parms.points -= pawn.kindDef.combatPower;
__result = pawn;
return(false);
}
else
{
return(true);
}
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
if (!TryGetRandomAvailableTargetMap(map: out Map map))
{
return(false);
}
SettlementBase settlement = RandomNearbyTradeableSettlement(originTile: map.Tile);
if (settlement != null)
{
//TODO: look into making the below dynamic based on requester's biome, faction, pirate outpost vicinity and other stuff.
ThingCategoryDef thingCategoryDef = DetermineThingCategoryDef();
string letterToSend = DetermineLetterToSend(thingCategoryDef: thingCategoryDef);
int feeRequest = Math.Max(val1: Rand.Range(min: 150, max: 300), val2: (int)parms.points);
string categorylabel = (thingCategoryDef == ThingCategoryDefOf.PlantFoodRaw) ? thingCategoryDef.label + " items" : thingCategoryDef.label;
//ChoiceLetter_ReverseTradeRequest choiceLetterReverseTradeRequest = (ChoiceLetter_ReverseTradeRequest)LetterMaker.MakeLetter(label: this.def.letterLabel, text: letterToSend.Translate(
// settlement.Faction.leader.LabelShort,
// settlement.Faction.def.leaderTitle,
// settlement.Faction.Name,
// settlement.Label,
// categorylabel,
// feeRequest
//).AdjustedFor(p: settlement.Faction.leader), def: this.def.letterDef);
//choiceLetterReverseTradeRequest.title = "MFI_ReverseTradeRequestTitle".Translate(map.info.parent.Label).CapitalizeFirst();
//choiceLetterReverseTradeRequest.thingCategoryDef = thingCategoryDef;
//choiceLetterReverseTradeRequest.map = map;
//parms.target = map;
//choiceLetterReverseTradeRequest.incidentParms = parms;
//choiceLetterReverseTradeRequest.faction = settlement.Faction;
//choiceLetterReverseTradeRequest.fee = feeRequest;
//choiceLetterReverseTradeRequest.StartTimeout(duration: TimeoutTicks);
//choiceLetterReverseTradeRequest.tile = settlement.Tile;
//Find.LetterStack.ReceiveLetter(let: choiceLetterReverseTradeRequest);
//Find.World.GetComponent<WorldComponent_OutpostGrower>().Registerletter(choiceLetterReverseTradeRequest);
DiaNode diaNode = new DiaNode(letterToSend.Translate(
settlement.Faction.leader.LabelShort,
settlement.Faction.def.leaderTitle,
settlement.Faction.Name,
settlement.Label,
categorylabel,
feeRequest
).AdjustedFor(p: settlement.Faction.leader));
int traveltime = this.CalcuteTravelTimeForTrader(originTile: settlement.Tile, map);
DiaOption accept = new DiaOption(text: "RansomDemand_Accept".Translate())
{
action = () =>
{
//spawn a trader with a stock gen that accepts our goods, has decent-ish money and nothing else.
//first attempt had a newly created trader for each, but the game can't save that. Had to define in XML.
parms.faction = settlement.Faction;;
TraderKindDef traderKind = DefDatabase <TraderKindDef> .GetNamed(defName : "MFI_EmptyTrader_" + thingCategoryDef);
traderKind.stockGenerators.First(predicate: x => x.HandlesThingDef(thingDef: ThingDefOf.Silver)).countRange.max += feeRequest;
traderKind.stockGenerators.First(predicate: x => x.HandlesThingDef(thingDef: ThingDefOf.Silver)).countRange.min += feeRequest;
traderKind.label = thingCategoryDef.label + " " + "MFI_Trader".Translate();
parms.traderKind = traderKind;
parms.forced = true;
Find.Storyteller.incidentQueue.Add(def: IncidentDefOf.TraderCaravanArrival, fireTick: Find.TickManager.TicksGame + traveltime, parms: parms);
TradeUtility.LaunchSilver(map: map, fee: feeRequest);
},
};
DiaNode acceptLink = new DiaNode(text: "MFI_TraderSent".Translate(
settlement.Faction.leader?.LabelShort,
traveltime.ToStringTicksToPeriodVague(vagueMin: false)
).CapitalizeFirst());
acceptLink.options.Add(DiaOption.DefaultOK);
accept.link = acceptLink;
if (!TradeUtility.ColonyHasEnoughSilver(map: map, fee: feeRequest))
{
accept.Disable(newDisabledReason: "NeedSilverLaunchable".Translate(feeRequest.ToString()));
}
DiaOption reject = new DiaOption(text: "RansomDemand_Reject".Translate())
{
action = () =>
{
},
resolveTree = true
};
diaNode.options = new List <DiaOption> {
accept, reject
};
Find.WindowStack.Add(new Dialog_NodeTreeWithFactionInfo(diaNode, settlement.Faction, title: "MFI_ReverseTradeRequestTitle".Translate(map.info.parent.Label).CapitalizeFirst()));
Find.Archive.Add(new ArchivedDialog(diaNode.text, "MFI_ReverseTradeRequestTitle".Translate(map.info.parent.Label).CapitalizeFirst(), settlement.Faction));
return(true);
}
return(false);
}
private static bool CompQuality_TradeQualityIncreasePreFix(CompQuality __instance, TraderKindDef trader, int forTile, Faction forFaction)
{
//forTile is assigned in RimWorld.ThingSetMaker_TraderStock.Generate. It's either a best-effort map, or -1.
Map map = null;
if (forTile != -1)
{
map = Current.Game.FindMap(tile: forTile);
}
__instance.SetQuality(q: FactionAndGoodWillDependantQuality(faction: forFaction, map: map, trader: trader), source: ArtGenerationContext.Outsider);
return(false);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
return(false); //Disabled for now
Map map = (Map)parms.target;
if (!base.TryResolveParms(parms))
{
return(false);
}
if (parms.faction.HostileTo(Faction.OfPlayer))
{
return(false);
}
List <Pawn> list = BoatStrategyWorker.GeneratePawnsForBoats(parms, PawnGroupKindDef);
if (list.Count <= 0)
{
return(false);
}
foreach (Pawn p in list)
{
if (p.needs != null && p.needs.food != null)
{
p.needs.food.CurLevel = p.needs.food.MaxLevel;
}
}
TraderKindDef traderKind = null;
foreach (Pawn p in list)
{
if (p.TraderKind != null)
{
traderKind = p.TraderKind;
break;
}
}
List <Pawn> ships = BoatStrategyWorker.GenerateBoatsForIncident(parms, PawnGroupKindDef, ref list);
if (!ships.Any())
{
return(false);
}
List <IntVec3> usedCells = new List <IntVec3>();
Predicate <IntVec3> validator = (IntVec3 c) => GenGridShips.Standable(c, map, MapExtensionUtility.GetExtensionToMap(map)) && !c.Fogged(map);
IntVec3 root = CellFinderExtended.MiddleEdgeCell(Find.World.CoastDirectionAt(map.Tile), map, ships.MaxBy(x => x.def.size.z), validator);
List <Thing> thingShips = new List <Thing>();
foreach (Pawn s in ships)
{
IntVec3 loc = !usedCells.Any() ? CellFinderExtended.MiddleEdgeCell(Find.World.CoastDirectionAt(map.Tile), map, s, validator) :
CellFinderExtended.RandomEdgeCell(Find.World.CoastDirectionAt(map.Tile), map, validator, usedCells, s);
usedCells.Add(loc);
Thing shipSpawned = GenSpawn.Spawn(s, loc, map, WipeMode.Vanish);
shipSpawned.Rotation = Find.World.CoastDirectionAt(map.Tile).Opposite;
thingShips.Add(shipSpawned);
}
List <Pawn> pawnsLeft = list;
pawnsLeft.SortBy(x => x.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation));
foreach (Thing t in thingShips)
{
for (int i = 0; i < t.TryGetComp <CompShips>().PawnCountToOperate; i++)
{
if (pawnsLeft.Count <= 0)
{
break;
}
t.TryGetComp <CompShips>().BoardDirectly(pawnsLeft.Pop(), t.TryGetComp <CompShips>().NextAvailableHandler.handlers);
}
if (pawnsLeft.Count <= 0)
{
break;
}
}
int iter = 0;
for (int i = 0; i < pawnsLeft.Count; i++)
{
Thing ship = thingShips[iter];
Pawn p = pawnsLeft.Pop();
ship.TryGetComp <CompShips>().BoardDirectly(p, ship.TryGetComp <CompShips>().NextAvailableHandler.handlers);
iter = iter + 1 >= thingShips.Count ? 0 : iter + 1;
}
foreach (Thing s in thingShips)
{
(s as Pawn).drafter.Drafted = true;
}
string label = "LetterLabelTraderCaravanArrival".Translate(parms.faction.Name, traderKind.label).CapitalizeFirst();
string text = "LetterTraderCaravanArrival".Translate(parms.faction.Name, traderKind.label).CapitalizeFirst();
PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter(ships, ref label, ref text, "LetterRelatedPawnsNeutralGroup".Translate(Faction.OfPlayer.def.pawnsPlural), true, true);
Find.LetterStack.ReceiveLetter(label, text, LetterDefOf.PositiveEvent, ships[0], parms.faction, null);
RCellFinder.TryFindRandomSpotJustOutsideColony(ships[0], out IntVec3 chillSpot);
LordJob_TradeWithColony lordJob = new LordJob_TradeWithColony(parms.faction, chillSpot);
foreach (Pawn s in ships)
{
Job job = new Job(JobDefOf_Ships.DisembarkLord, FindShoreline(s));
s.jobs.TryTakeOrderedJob(job, JobTag.Misc);
s.GetComp <CompShips>().lordJobToAssign = lordJob;
s.GetComp <CompShips>().lordShipGroup.AddRange(ships);
}
return(true);
}
/// <summary>
/// Trade dialog for AerialVehicle WorldObject
/// </summary>
/// <param name="aerialVehicle"></param>
/// <param name="faction"></param>
/// <param name="trader"></param>
public static Command_Action AerialVehicleTradeCommand(this AerialVehicleInFlight aerialVehicle, Faction faction = null, TraderKindDef trader = null)
{
Pawn bestNegotiator = WorldHelper.FindBestNegotiator(aerialVehicle.vehicle, faction, trader);
Command_Action command_Action = new Command_Action();
command_Action.defaultLabel = "CommandTrade".Translate();
command_Action.defaultDesc = "CommandTradeDesc".Translate();
command_Action.icon = VehicleTex.TradeCommandTex;
command_Action.action = delegate()
{
Settlement settlement = Find.WorldObjects.SettlementAt(aerialVehicle.Tile);
if (settlement != null && settlement.CanTradeNow)
{
Find.WindowStack.Add(new Dialog_TradeAerialVehicle(aerialVehicle, bestNegotiator, settlement, false));
PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(settlement.Goods.OfType <Pawn>(), "LetterRelatedPawnsTradingWithSettlement".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, false, true);
}
};
if (bestNegotiator is null)
{
if (trader != null && trader.permitRequiredForTrading != null && !aerialVehicle.vehicle.AllPawnsAboard.Any((Pawn p) => p.royalty != null && p.royalty.HasPermit(trader.permitRequiredForTrading, faction)))
{
command_Action.Disable("CommandTradeFailNeedPermit".Translate(trader.permitRequiredForTrading.LabelCap));
}
else
{
command_Action.Disable("CommandTradeFailNoNegotiator".Translate());
}
}
if (bestNegotiator != null && bestNegotiator.skills.GetSkill(SkillDefOf.Social).TotallyDisabled)
{
command_Action.Disable("CommandTradeFailSocialDisabled".Translate());
}
return(command_Action);
}
public LandedShip(Map map, TraderKindDef def, Faction faction = null) : base(def, faction)
{
this.map = map;
passingShipManager = map.passingShipManager;
}
public override void PostPostGeneratedForTrader(TraderKindDef trader, int forTile, Faction forFaction)
{
base.PostPostGeneratedForTrader(trader, forTile, forFaction);
this.hatcheeFaction = forFaction;
}
/* Private Methods */
private Pawn GenerateVendor(PawnGroupMakerParms parms, PawnGroupMaker groupMaker, TraderKindDef traderKind, bool subtractPoints)
{
if (subtractPoints)
{
if (parms.points < _DefOf.CarnyTrader.combatPower * 2)
{
return(null);
}
else
{
parms.points -= _DefOf.CarnyTrader.combatPower * 2;
}
}
// Generate new vendor
PawnGenerationRequest request = new PawnGenerationRequest(
_DefOf.CarnyTrader,
parms.faction,
PawnGenerationContext.NonPlayer,
parms.tile,
false,
false,
false,
false,
true,
false,
1f,
true, // Force free warm layers if needed
true,
true,
parms.inhabitants,
false,
null, // Consider adding predicate for backstory here
null,
null,
null,
null,
null
);
var vendor = PawnGenerator.GeneratePawn(request);
vendor.mindState.wantsToTradeWithColony = true;
PawnComponentsUtility.AddAndRemoveDynamicComponents(vendor, true);
vendor.trader.traderKind = traderKind;
return(vendor);
}
private static bool TryConvertOnePawnToSmallTrader(List <Pawn> pawns, Faction faction, Map map, out int traderIndex)
{
if (faction.def.visitorTraderKinds.NullOrEmpty())
{
traderIndex = 0;
return(false);
}
Pawn pawn = pawns.RandomElement();
Lord lord = pawn.GetLord();
pawn.mindState.wantsToTradeWithColony = true;
PawnComponentsUtility.AddAndRemoveDynamicComponents(pawn, true);
TraderKindDef traderKindDef = faction.def.visitorTraderKinds.RandomElementByWeight(traderDef => traderDef.commonality);
pawn.trader.traderKind = traderKindDef;
pawn.inventory.DestroyAll();
pawn.TryGiveBackpack();
var parms = default(ThingSetMakerParams);
parms.traderDef = traderKindDef;
parms.tile = map.Tile;
parms.traderFaction = faction;
foreach (Thing current in ThingSetMakerDefOf.TraderStock.root.Generate(parms))
{
Pawn slave = current as Pawn;
if (slave != null)
{
if (slave.Faction != pawn.Faction)
{
slave.SetFaction(pawn.Faction);
}
IntVec3 loc = CellFinder.RandomClosewalkCellNear(pawn.Position, lord.Map, 5);
GenSpawn.Spawn(slave, loc, lord.Map);
lord.AddPawn(slave);
}
else
{
var spaceFor = pawn.GetInventorySpaceFor(current);
if (current.Destroyed)
{
continue;
}
if (spaceFor <= 0)
{
current.Destroy();
continue;
}
current.stackCount = spaceFor;
// Core stuff
if (!pawn.inventory.innerContainer.TryAdd(current))
{
current.Destroy();
}
}
}
traderIndex = pawns.IndexOf(pawn);
return(true);
}
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;
}
