public DiaNode GetAirStrikeDetailsDiaNode(DiaNode parentNode, AirStrikeDef strikeDef)
{
DiaNode airStrikeDetailsDiaNode = new DiaNode(strikeDef.LabelCap + "\n\n"
+ strikeDef.description + "\n\n"
+ "Runs number: " + strikeDef.runsNumber + "\n\n"
+ "Cost: " + strikeDef.costInSilver + " silvers");
DiaOption airStrikeConfirmDiaOption = new DiaOption("Confirm");
airStrikeConfirmDiaOption.action = delegate
{
this.previousTimeSpeed = Find.TickManager.CurTimeSpeed;
Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
this.selectedStrikeDef = strikeDef;
Util_Misc.SelectAirStrikeTarget(this.Map, SpawnAirStrikeBeacon);
};
airStrikeConfirmDiaOption.resolveTree = true;
if (TradeUtility.ColonyHasEnoughSilver(this.Map, strikeDef.costInSilver) == false)
{
airStrikeConfirmDiaOption.Disable("not enough silver");
}
airStrikeDetailsDiaNode.options.Add(airStrikeConfirmDiaOption);
DiaOption airStrikeBackDiaOption = new DiaOption("Back");
airStrikeBackDiaOption.link = parentNode;
airStrikeDetailsDiaNode.options.Add(airStrikeBackDiaOption);
return(airStrikeDetailsDiaNode);
}
public void AddAllTradeables()
{
foreach (Thing current in TradeSession.trader.ColonyThingsWillingToBuy(TradeSession.playerNegotiator))
{
if (TradeUtility.PlayerSellableNow(current))
{
this.AddToTradeables(current, Transactor.Colony);
}
}
if (!TradeSession.giftMode)
{
foreach (Thing current2 in TradeSession.trader.Goods)
{
this.AddToTradeables(current2, Transactor.Trader);
}
}
//if (!TradeSession.giftMode)
//{
// if (this.tradeables.Find((Tradeable x) => x.IsCurrency) == null)
// {
// Thing thing = ThingMaker.MakeThing(ThingDefOf.Silver, null);
// thing.stackCount = 0;
// this.AddToTradeables(thing, Transactor.Trader);
// }
//}
}
public static int GetGoodwillChange(IEnumerable <IThingHolder> pods, SettlementBase giveTo)
{
float num = 0f;
foreach (IThingHolder current in pods)
{
ThingOwner directlyHeldThings = current.GetDirectlyHeldThings();
for (int i = 0; i < directlyHeldThings.Count; i++)
{
float singlePrice;
if (directlyHeldThings[i].def == ThingDefOf.Silver)
{
singlePrice = directlyHeldThings[i].MarketValue;
}
else
{
float priceFactorSell_TraderPriceType = (giveTo.TraderKind == null) ? 1f : giveTo.TraderKind.PriceTypeFor(directlyHeldThings[i].def, TradeAction.PlayerSells).PriceMultiplier();
float tradePriceImprovementOffsetForPlayer = giveTo.TradePriceImprovementOffsetForPlayer;
singlePrice = TradeUtility.GetPricePlayerSell(directlyHeldThings[i], priceFactorSell_TraderPriceType, 1f, tradePriceImprovementOffsetForPlayer);
}
num += FactionGiftUtility.GetBaseGoodwillChange(directlyHeldThings[i], directlyHeldThings[i].stackCount, singlePrice, giveTo.Faction);
}
}
return(FactionGiftUtility.PostProcessedGoodwillChange(num, giveTo.Faction));
}
internal static float PriceFor(this Tradeable _this, TradeAction action)
{
float num = TradeSession.trader.TraderKind.PriceTypeFor(_this.ThingDef, action).PriceMultiplier();
float num2 = TradeUtility.RandomPriceFactorFor(TradeSession.trader, _this);
float num3;
if (action == TradeAction.PlayerBuys)
{
num3 = _this.BaseMarketValue * (1f - TradeSession.playerNegotiator.GetStatValue(StatDefOf.TradePriceImprovement, true)) * num * num2;
num3 = Mathf.Max(num3, 0.5f);
}
else
{
num3 = _this.BaseMarketValue * Find.Storyteller.difficulty.baseSellPriceFactor * _this.AnyThing.GetStatValue(StatDefOf.SellPriceFactor, true) * (1f + TradeSession.playerNegotiator.GetStatValue(StatDefOf.TradePriceImprovement, true)) * num * num2;
num3 *= Detours_Tradeable.LaunchPricePostFactorCurve.Evaluate(num3);
num3 = Mathf.Max(num3, 0.01f);
if (num3 >= _this.PriceFor(TradeAction.PlayerBuys))
{
Log.ErrorOnce("Skill of negotitator trying to put sell price above buy price.", 65387);
num3 = _this.PriceFor(TradeAction.PlayerBuys);
}
}
if (num3 > 99.5f)
{
num3 = Mathf.Round(num3);
}
return(num3);
}
public virtual void GiveSoldThingToPlayer(Thing toGive, int countToGive, Pawn playerNegotiator)
{
Thing thing = toGive.SplitOff(countToGive);
thing.PreTraded(TradeAction.PlayerBuys, playerNegotiator, this);
TradeUtility.SpawnDropPod(DropCellFinder.TradeDropSpot(Find.CurrentMap), Find.CurrentMap, thing);
}
public DiaOption GetMedicalSupplyDiaOption(Building_OrbitalRelay orbitalRelay)
{
DiaOption medicalSupplyDiaOption = new DiaOption("Request medical supply (" + Util_Spaceship.medicalSupplyCostInSilver + " silver)");
Building_LandingPad landingPad = Util_LandingPad.GetBestAvailableLandingPad(this.Map);
if (Find.TickManager.TicksGame <= Util_Misc.Partnership.nextMedicalSupplyMinTick[this.Map])
{
medicalSupplyDiaOption.Disable("no available ship for now");
}
else if (TradeUtility.ColonyHasEnoughSilver(this.Map, Util_Spaceship.medicalSupplyCostInSilver) == false)
{
medicalSupplyDiaOption.Disable("not enough silver");
}
else if (landingPad == null)
{
medicalSupplyDiaOption.Disable("no available landing pad");
}
medicalSupplyDiaOption.action = delegate
{
TradeUtility.LaunchSilver(this.Map, Util_Spaceship.medicalSupplyCostInSilver);
Util_Spaceship.SpawnSpaceship(landingPad, SpaceshipKind.Medical);
};
DiaNode supplyShipAcceptedDiaNode = new DiaNode("\"We are sending you a medical ship immediately.\n\n"
+ "Hold on down there, we're coming!\n\n"
+ "-- End of transmission --");
DiaOption supplyShipAcceptedDiaOption = new DiaOption("OK");
supplyShipAcceptedDiaOption.resolveTree = true;
supplyShipAcceptedDiaNode.options.Add(supplyShipAcceptedDiaOption);
medicalSupplyDiaOption.link = supplyShipAcceptedDiaNode;
return(medicalSupplyDiaOption);
}
public DiaOption GetCargoSupplyDiaOption(Building_OrbitalRelay orbitalRelay)
{
DiaOption cargoSupplyDiaOption = new DiaOption("Request cargo supply (" + Util_Spaceship.cargoSupplyCostInSilver + " silver)");
Building_LandingPad landingPad = Util_LandingPad.GetBestAvailableLandingPad(this.Map);
if (Find.TickManager.TicksGame <= Util_Misc.Partnership.nextRequestedSupplyMinTick[this.Map])
{
cargoSupplyDiaOption.Disable("no available ship for now");
}
else if (TradeUtility.ColonyHasEnoughSilver(this.Map, Util_Spaceship.cargoSupplyCostInSilver) == false)
{
cargoSupplyDiaOption.Disable("not enough silver");
}
else if (landingPad == null)
{
cargoSupplyDiaOption.Disable("no available landing pad");
}
cargoSupplyDiaOption.action = delegate
{
TradeUtility.LaunchSilver(this.Map, Util_Spaceship.cargoSupplyCostInSilver);
Util_Spaceship.SpawnSpaceship(landingPad, SpaceshipKind.CargoRequested);
};
DiaNode supplyShipAcceptedDiaNode = new DiaNode("\"Alright, a supply ship should arrive soon with our best stuff.\n"
+ "Greetings partner!\"\n\n"
+ "-- End of transmission --");
DiaOption supplyShipAcceptedDiaOption = new DiaOption("OK");
supplyShipAcceptedDiaOption.resolveTree = true;
supplyShipAcceptedDiaNode.options.Add(supplyShipAcceptedDiaOption);
cargoSupplyDiaOption.link = supplyShipAcceptedDiaNode;
return(cargoSupplyDiaOption);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (forced == false)
{
return(false);
}
Pawn otherPawn = t as Pawn;
if ((otherPawn == null) ||
(pawn.Faction != otherPawn.Faction) ||
otherPawn.def.race.Animal)
{
return(false);
}
if (Util_Misc.OrbitalHealing.HasAnyTreatableHediff(otherPawn) == false)
{
return(false);
}
foreach (Thing spaceship in pawn.Map.listerThings.ThingsOfDef(Util_Spaceship.SpaceshipMedical))
{
Building_SpaceshipMedical medicalSpaceship = spaceship as Building_SpaceshipMedical;
if ((medicalSpaceship != null) &&
otherPawn.Downed &&
pawn.CanReserveAndReach(otherPawn, this.PathEndMode, Danger.Deadly, ignoreOtherReservations: true) &&
pawn.CanReach(spaceship, this.PathEndMode, Danger.Deadly) &&
(medicalSpaceship.orbitalHealingPawnsAboardCount < Building_SpaceshipMedical.orbitalHealingPawnsAboardMaxCount) &&
TradeUtility.ColonyHasEnoughSilver(pawn.Map, Util_Spaceship.orbitalHealingCost))
{
return(true);
}
}
return(false);
}
public override void TryExecute()
{
ThingDef itemDef = ThingDef.Named("DropPodIncoming");
Thing itemThing = new Thing();
ThingDef stuff = null;
ThingDef itemThingDef = ThingDef.Named(item.defname);
if (itemThingDef.race != null)
{
TryExecuteAnimal(itemThingDef, quantity);
return;
}
if (itemThingDef.MadeFromStuff)
{
if (!(from x in GenStuff.AllowedStuffsFor(itemThingDef, TechLevel.Undefined)
where !PawnWeaponGenerator.IsDerpWeapon(itemThingDef, x)
select x).TryRandomElementByWeight((ThingDef x) => x.stuffProps.commonality, out stuff))
{
stuff = GenStuff.RandomStuffByCommonalityFor(itemThingDef, TechLevel.Undefined);
}
}
itemThing = ThingMaker.MakeThing(itemThingDef, (stuff != null) ? stuff : null);
QualityCategory q = new QualityCategory();
if (itemThing.TryGetQuality(out q))
{
ItemHelper.setItemQualityRandom(itemThing);
}
Map map = Helper.AnyPlayerMap;
IntVec3 vec = DropCellFinder.TradeDropSpot(map);
if (itemThingDef.Minifiable)
{
itemThingDef = itemThingDef.minifiedDef;
MinifiedThing minifiedThing = (MinifiedThing)ThingMaker.MakeThing(itemThingDef, null);
minifiedThing.InnerThing = itemThing;
minifiedThing.stackCount = quantity;
TradeUtility.SpawnDropPod(vec, map, minifiedThing);
}
else
{
itemThing.stackCount = quantity;
TradeUtility.SpawnDropPod(vec, map, itemThing);
}
string letter = Helper.ReplacePlaceholder("TwitchStoriesDescription80".Translate(), from: Viewer.username, amount: quantity.ToString(), item: item.abr.CapitalizeFirst());
LetterDef letterDef = ItemHelper.GetLetterFromValue(price);
Find.LetterStack.ReceiveLetter(item.abr.Truncate(15, true).CapitalizeFirst(), letter, letterDef, new TargetInfo(vec, map, false));
EndCarePackage();
}
public static bool CanUpgradeDruglabs(Faction faction, List <Thing> requirements, int level)
{
requirements.Clear();
Thing silver = ThingMaker.MakeThing(ThingDefOf.Silver);
Thing hops = ThingMaker.MakeThing(ThingCategoryDefOf.PlantMatter.childThingDefs.Find(x => x.defName == "RawHops"));
Thing smokeleaf = ThingMaker.MakeThing(ThingCategoryDefOf.PlantMatter.childThingDefs.Find(x => x.defName == "SmokeleafLeaves"));
Thing psyLeaves = ThingMaker.MakeThing(ThingCategoryDefOf.PlantMatter.childThingDefs.Find(x => x.defName == "PsychoidLeaves"));
switch (level)
{
case 0:
silver.stackCount = 1000;
requirements.Add(silver);
hops.stackCount = 200;
requirements.Add(hops);
smokeleaf.stackCount = 200;
requirements.Add(smokeleaf);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == hops.def).Sum(t => t.stackCount) >= hops.stackCount && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == smokeleaf.def).Sum(t => t.stackCount) >= smokeleaf.stackCount)
{
return(true);
}
return(false);
case 1:
silver.stackCount = 4500;
requirements.Add(silver);
psyLeaves.stackCount = 150;
requirements.Add(psyLeaves);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == psyLeaves.def).Sum(t => t.stackCount) >= psyLeaves.stackCount)
{
return(true);
}
return(false);
case 2:
silver.stackCount = 7000;
requirements.Add(silver);
psyLeaves.stackCount = 500;
requirements.Add(psyLeaves);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == psyLeaves.def).Sum(t => t.stackCount) >= psyLeaves.stackCount)
{
return(true);
}
return(false);
case 3:
silver.stackCount = 13000;
requirements.Add(silver);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount))
{
return(true);
}
return(false);
default:
return(false);
}
}
static void addOptions(Map map, List <FloatMenuOption> opts)
{
if (orbitalTraders.Count == 0)
{
foreach (var d in DefDatabase <TraderKindDef> .AllDefsListForReading)
{
if (d.orbital)
{
orbitalTraders.Add(d);
}
}
orbitalTraders.Sort(delegate(TraderKindDef d1, TraderKindDef d2)
{
return(d1.label.CompareTo(d2.label));
});
}
if (Settings.Cost > 0)
{
int found = 0;
foreach (Thing t in TradeUtility.AllLaunchableThingsForTrade(map))
{
if (t.def == ThingDefOf.Silver)
{
found += t.stackCount;
if (found > Settings.Cost)
{
break;
}
}
}
if (found < Settings.Cost)
{
opts.Add(new FloatMenuOption("CallTradeShips.NotEnoughSilver".Translate(found, Settings.Cost), null));
return;
}
}
foreach (var d in orbitalTraders)
{
opts.Add(new FloatMenuOption(getMenuLabel(d), delegate()
{
TradeShip tradeShip = new TradeShip(d);
if (map.listerBuildings.allBuildingsColonist.Any((Building b) => b.def.IsCommsConsole && b.GetComp <CompPowerTrader>().PowerOn))
{
TradeUtility.LaunchSilver(map, Settings.Cost);
Find.LetterStack.ReceiveLetter(tradeShip.def.LabelCap, "TraderArrival".Translate(
tradeShip.name,
tradeShip.def.label,
"TraderArrivalNoFaction".Translate()
), LetterDefOf.PositiveEvent, null);
}
map.passingShipManager.AddShip(tradeShip);
tradeShip.GenerateThings();
}, MenuOptionPriority.Low));
}
}
public override void DoWindowContents(Rect inRect)
{
Listing_Standard listingStandard = new Listing_Standard();
listingStandard.Begin(inRect);
listingStandard.Label("RansomBargain".Translate(this.prisoner.Name.ToStringFull, this.prisoner.Faction.Name));
listingStandard.Gap();
listingStandard.Gap();
listingStandard.Gap();
listingStandard.Label(label: $"RansomDemandAmount".Translate(RansomSettings.MarketValuePercentage(this.prisoner, this.percentage).ToString(CultureInfo.CurrentCulture), ThingDefOf.Silver.LabelCap));
this.percentage = listingStandard.Slider(this.percentage, -50f, 50f);
listingStandard.Gap();
listingStandard.Label(label: $"RansomDemandChance".Translate(Mathf.RoundToInt(RansomSettings.RansomChance(this.prisoner, this.handler, this.percentage) * 100).ToString(CultureInfo.CurrentCulture)));
if (listingStandard.ButtonText("RansomSendOffer".Translate()))
{
Faction faction = this.prisoner.Faction;
if (Rand.Value < RansomSettings.RansomChance(this.prisoner, this.handler, this.percentage))
{
Messages.Message(text: "RansomFactionDeliveredMessage".Translate(), def: MessageTypeDefOf.PositiveEvent);
Thing silver = ThingMaker.MakeThing(def: ThingDefOf.Silver);
silver.stackCount = RansomSettings.MarketValuePercentage(this.prisoner, this.percentage);
TradeUtility.SpawnDropPod(dropSpot: DropCellFinder.TradeDropSpot(map: this.prisoner.Map), map: this.prisoner.Map, t: silver);
if (this.prisoner.Spawned)
{
GenGuest.PrisonerRelease(p: this.prisoner);
this.prisoner.DeSpawn();
}
//TaleRecorder.RecordTale(TaleDefOf.SoldPrisoner, this.handler, this.prisoner);
//faction.TryAffectGoodwillWith(other: Faction.OfPlayer, RansomSettings.settings.ransomGoodwill);
Find.WindowStack.Add(new Dialog_MessageBox("RansomPrisonerSend".Translate()));
}
else
{
Find.WindowStack.Add(new Dialog_MessageBox("RansomNotAccepted".Translate()));
//faction.TryAffectGoodwillWith(other: Faction.OfPlayer, goodwillChange: RansomSettings.settings.ransomGoodwillFail);
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, this.prisoner.Map);
incidentParms.faction = faction;
incidentParms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
Find.Storyteller.incidentQueue.Add(IncidentDefOf.RaidEnemy, Find.TickManager.TicksGame + RansomSettings.settings.ransomRaidDelay, incidentParms, RansomSettings.settings.ransomRaidDelay);
}
this.Close();
}
if (listingStandard.ButtonText("Back".Translate()))
{
this.Close();
}
}
public virtual IEnumerable <Thing> ColonyThingsWillingToBuy(Pawn playerNegotiator)
{
foreach (Thing item in TradeUtility.AllLaunchableThingsForTrade(Find.CurrentMap))
{
if (item.def == BankDefOf.BankNote || item.def == ThingDefOf.Silver)
{
yield return(item);
}
}
}
public void MindStateTick()
{
if (wantsToTradeWithColony)
{
TradeUtility.CheckInteractWithTradersTeachOpportunity(pawn);
}
if (meleeThreat != null && !MeleeThreatStillThreat)
{
meleeThreat = null;
}
mentalStateHandler.MentalStateHandlerTick();
mentalBreaker.MentalBreakerTick();
inspirationHandler.InspirationHandlerTick();
if (!pawn.GetPosture().Laying())
{
applyBedThoughtsTick = 0;
}
if (pawn.IsHashIntervalTick(100))
{
if (pawn.Spawned)
{
int regionsToScan = (!anyCloseHostilesRecently) ? 18 : 24;
anyCloseHostilesRecently = PawnUtility.EnemiesAreNearby(pawn, regionsToScan, passDoors: true);
}
else
{
anyCloseHostilesRecently = false;
}
}
if (WillJoinColonyIfRescued && AnythingPreventsJoiningColonyIfRescued)
{
WillJoinColonyIfRescued = false;
}
if (pawn.Spawned && pawn.IsWildMan() && !WildManEverReachedOutside && pawn.GetRoom() != null && pawn.GetRoom().TouchesMapEdge)
{
WildManEverReachedOutside = true;
}
if (Find.TickManager.TicksGame % 123 == 0 && pawn.Spawned && pawn.RaceProps.IsFlesh && pawn.needs.mood != null)
{
TerrainDef terrain = pawn.Position.GetTerrain(pawn.Map);
if (terrain.traversedThought != null)
{
pawn.needs.mood.thoughts.memories.TryGainMemoryFast(terrain.traversedThought);
}
WeatherDef curWeatherLerped = pawn.Map.weatherManager.CurWeatherLerped;
if (curWeatherLerped.exposedThought != null && !pawn.Position.Roofed(pawn.Map))
{
pawn.needs.mood.thoughts.memories.TryGainMemoryFast(curWeatherLerped.exposedThought);
}
}
if (GenLocalDate.DayTick(pawn) == 0)
{
interactionsToday = 0;
}
}
// ===================== Float menu options =====================
public override IEnumerable <FloatMenuOption> GetFloatMenuOptions(Pawn selPawn)
{
List <FloatMenuOption> options = new List <FloatMenuOption>();
if (selPawn.CanReach(this, PathEndMode.ClosestTouch, Danger.Some, false, TraverseMode.ByPawn) == false)
{
return(GetFloatMenuOptionsCannotReach(selPawn));
}
// Base options.
foreach (FloatMenuOption option in base.GetFloatMenuOptions(selPawn))
{
options.Add(option);
}
// Board to get orbital healing option.
if (this.IsBurning())
{
FloatMenuOption burningOption = new FloatMenuOption("CannotUseReason".Translate(new object[]
{
"BurningLower".Translate()
}), null);
options.Add(burningOption);
}
else
{
FloatMenuOption boardOption = null;
if (Util_Misc.OrbitalHealing.HasAnyTreatableHediff(selPawn))
{
if (this.orbitalHealingPawnsAboardCount >= orbitalHealingPawnsAboardMaxCount)
{
string optionLabel = "Board medical spaceship (no free slot)";
boardOption = new FloatMenuOption(optionLabel, null);
}
else if (TradeUtility.ColonyHasEnoughSilver(this.Map, Util_Spaceship.orbitalHealingCost))
{
Action action = delegate
{
Job job = new Job(Util_JobDefOf.BoardMedicalSpaceship, this);
selPawn.jobs.TryTakeOrderedJob(job);
};
string optionLabel = "Board medical spaceship (" + Util_Spaceship.orbitalHealingCost + " silver)";
boardOption = new FloatMenuOption(optionLabel, action);
}
else
{
string optionLabel = "Board medical spaceship (" + Util_Spaceship.orbitalHealingCost + " silver) (not enough silver)";
boardOption = new FloatMenuOption(optionLabel, null);
}
options.Add(boardOption);
}
}
return(options);
}
public void SpawnAirStrikeBeacon(LocalTargetInfo targetPosition)
{
TradeUtility.LaunchSilver(this.Map, this.selectedStrikeDef.costInSilver);
Building_AirStrikeBeacon AirStrikeBeacon = GenSpawn.Spawn(Util_ThingDefOf.AirStrikeBeacon, targetPosition.Cell, this.Map) as Building_AirStrikeBeacon;
AirStrikeBeacon.InitializeAirStrike(targetPosition.Cell, this.selectedStrikeDef);
AirStrikeBeacon.SetFaction(Faction.OfPlayer);
Messages.Message("Air strike target confirmed!", AirStrikeBeacon, MessageTypeDefOf.CautionInput);
Find.TickManager.CurTimeSpeed = this.previousTimeSpeed;
Util_Misc.Partnership.nextAirstrikeMinTick[this.Map] = Find.TickManager.TicksGame + Mathf.RoundToInt(selectedStrikeDef.ammoResupplyDays * GenDate.TicksPerDay);
}
public virtual void GiveSoldThingToTrader(Thing toGive, int countToGive, Pawn playerNegotiator)
{
Thing thing = toGive.SplitOff(countToGive);
thing.PreTraded(TradeAction.PlayerSells, playerNegotiator, this);
Thing thing2 = TradeUtility.ThingFromStockToMergeWith(this, thing);
if (thing2 != null && !thing2.TryAbsorbStack(thing, respectStackLimit: false))
{
thing.Destroy();
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
Pawn downedPawn = this.TargetThingA as Pawn;
Toil gotoDownedPawnToil = Toils_Goto.GotoCell(downedPawnIndex, PathEndMode.OnCell).FailOn(delegate()
{
return(downedPawn.DestroyedOrNull() ||
(downedPawn.Downed == false));
});
yield return(gotoDownedPawnToil);
yield return(Toils_Haul.StartCarryThing(downedPawnIndex));
Toil gotoTravelDestToil = Toils_Haul.CarryHauledThingToCell(medicalSPaceshipCellIndex).FailOn(delegate()
{
return(this.pawn.carryTracker.CarriedThing.DestroyedOrNull() ||
(this.pawn.CanReach(this.pawn.jobs.curJob.targetB.Cell, PathEndMode.OnCell, Danger.Some) == false));
});
yield return(gotoTravelDestToil);
Toil arrivedToil = new Toil()
{
initAction = () =>
{
Thing carriedPawn = null;
this.pawn.carryTracker.TryDropCarriedThing(this.pawn.Position, ThingPlaceMode.Near, out carriedPawn);
Building_SpaceshipMedical medicalSpaceship = this.pawn.Position.GetFirstThing(this.pawn.Map, Util_Spaceship.SpaceshipMedical) as Building_SpaceshipMedical;
if (medicalSpaceship != null)
{
if (medicalSpaceship.orbitalHealingPawnsAboardCount >= Building_SpaceshipMedical.orbitalHealingPawnsAboardMaxCount)
{
Messages.Message((carriedPawn as Pawn).Name.ToStringShort + " cannot board MiningCo. medical spaceship.. There is no more any free slot.", carriedPawn, MessageTypeDefOf.RejectInput);
}
else if (TradeUtility.ColonyHasEnoughSilver(this.pawn.Map, Util_Spaceship.orbitalHealingCost))
{
TradeUtility.LaunchSilver(this.pawn.Map, Util_Spaceship.orbitalHealingCost);
medicalSpaceship.Notify_PawnBoarding(carriedPawn as Pawn, false);
}
else
{
Messages.Message((carriedPawn as Pawn).Name.ToStringShort + " cannot board MiningCo. medical spaceship.. You have not enough silver to pay for " + this.pawn.gender.GetPossessive() + " orbital healing.", carriedPawn, MessageTypeDefOf.RejectInput);
}
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(arrivedToil);
}
private static DiaOption ConfirmPurchase(Map map, ResearchProjectDef def)
{
DiaOption option = new DiaOption("Confirm".Translate())
{
linkLateBind = FactionDialogMaker_IoM.ResetToRoot()
};
option.action = delegate
{
TradeUtility.LaunchThingsOfType(ThingDefOf.Silver, (int)def.baseCost, map, null);
FactionDialogMaker_IoM.GrantMecResearch(def);
};
return(option);
}
public static bool MindStateTick(Pawn_MindState __instance)
{
if (__instance.wantsToTradeWithColony)
{
TradeUtility.CheckInteractWithTradersTeachOpportunity(__instance.pawn);
}
if (__instance.meleeThreat != null && !__instance.MeleeThreatStillThreat)
{
__instance.meleeThreat = null;
}
__instance.mentalStateHandler.MentalStateHandlerTick();
__instance.mentalBreaker.MentalBreakerTick();
__instance.inspirationHandler.InspirationHandlerTick();
if (!__instance.pawn.GetPosture().Laying())
{
__instance.applyBedThoughtsTick = 0;
}
if (__instance.pawn.IsHashIntervalTick(100))
{
__instance.anyCloseHostilesRecently = __instance.pawn.Spawned && PawnUtility.EnemiesAreNearby(__instance.pawn, __instance.anyCloseHostilesRecently ? 24 : 18, true);
}
if (__instance.WillJoinColonyIfRescued && __instance.AnythingPreventsJoiningColonyIfRescued)
{
__instance.WillJoinColonyIfRescued = false;
}
if (__instance.pawn.Spawned && __instance.pawn.IsWildMan() && (!__instance.WildManEverReachedOutside && __instance.pawn.GetRoom(RegionType.Set_Passable) != null) && __instance.pawn.GetRoom(RegionType.Set_Passable).TouchesMapEdge)
{
__instance.WildManEverReachedOutside = true;
}
if (Find.TickManager.TicksGame % 123 == 0 && __instance.pawn.Spawned && (__instance.pawn.RaceProps.IsFlesh && __instance.pawn.needs.mood != null))
{
TerrainDef terrain = __instance.pawn.Position.GetTerrain(__instance.pawn.Map);
if (terrain.traversedThought != null)
{
__instance.pawn.needs.mood.thoughts.memories.TryGainMemoryFast(terrain.traversedThought);
}
WeatherDef curWeatherLerped = __instance.pawn.Map.weatherManager.CurWeatherLerped;
if (curWeatherLerped.exposedThought != null && !__instance.pawn.Position.Roofed(__instance.pawn.Map))
{
__instance.pawn.needs.mood.thoughts.memories.TryGainMemoryFast(curWeatherLerped.exposedThought);
}
}
//dirty hack for easy speedup - i'm sure this breaks things like pawn conversation interval.
//if (GenLocalDate.DayTick((Thing)__instance.pawn) != 0)
// return;
__instance.interactionsToday = 0;
return(false);
}
public IEnumerable <Thing> ColonyThingsWillingToBuy(Pawn playerNegotiator)
{
//The result is a list of things that the pawn HAS, that are in a sellable position and that the trader accepts.
if (playerNegotiator != null)
{
if (playerNegotiator.Map != null)
{
return(TradeUtility.AllLaunchableThingsForTrade(playerNegotiator.Map).Where(t => TraderKind.WillTrade(t.def)));
}
else if (playerNegotiator.GetCaravan() != null)
{
return(playerNegotiator.GetCaravan().trader.Goods.Where(t => TraderKind.WillTrade(t.def)));
}
}
return(new List <Thing>());
}
public static void SpawnItem(IntVec3 position, Map map, Thing item)
{
var hatcher = item.TryGetComp <CompHatcher>();
if (hatcher != null)
{
hatcher.hatcheeFaction = Faction.OfPlayer;
}
if (Current.Game.GetComponent <Coordinator>()?.TrySpawnItem(map, item) == true)
{
return;
}
TradeUtility.SpawnDropPod(position, map, item);
}
public static IntVec3 Rain(ThingDef thingDef, Thing thing)
{
IntVec3 intVec;
if (!GetRandomVec3(thingDef, Helper.AnyPlayerMap, out intVec, 5))
{
return(intVec);
}
Map any = Helper.AnyPlayerMap;
intVec = DropCellFinder.TradeDropSpot(any);
TradeUtility.SpawnDropPod(intVec, any, thing);
return(intVec);
}
private static void Postfix(Pawn ___pawn, ref IEnumerable <Thing> __result, Pawn playerNegotiator)
{
var result = __result.ToList();
Map oldMap = ___pawn.Map;
IntVec3 oldPosition = playerNegotiator.Position;
bool select = false;
if (Find.Selector.SelectedObjects.Contains(___pawn))
{
select = true;
}
foreach (var map in ZUtils.GetAllMapsInClosestOrder(___pawn, oldMap, oldPosition))
{
if (map != oldMap)
{
IEnumerable <Thing> enumerable = ___pawn.Map.listerThings.AllThings.Where((Thing x)
=> x.def.category == ThingCategory.Item && TradeUtility.PlayerSellableNow(x, ___pawn) &&
!x.Position.Fogged(x.Map) && (___pawn.Map.areaManager.Home[x.Position] ||
x.IsInAnyStorage()) && ReachableForTrade(x, ___pawn));
foreach (Thing item in enumerable)
{
result.Add(item);
}
if (___pawn.GetLord() != null)
{
foreach (Pawn item2 in from x in TradeUtility.AllSellableColonyPawns(___pawn.Map)
where !x.Downed && ReachableForTrade(x, ___pawn)
select x)
{
result.Add(item2);
}
}
}
}
if (___pawn.Map != oldMap)
{
Traverse.Create(___pawn).Field("mapIndexOrState")
.SetValue((sbyte)Find.Maps.IndexOf(oldMap));
Traverse.Create(___pawn).Field("positionInt")
.SetValue(oldPosition);
}
if (select)
{
Find.Selector.Select(___pawn);
}
__result = result;
}
private static DiaOption OfferGiftOption(Map map)
{
// TODO: Compare with vanilla method
int cost = GetCost(Hospitality_MapComponent.Instance(map).GetBribeCount(faction));
//Log.Message(faction.name + ": " + Hospitality_MapComponent.Instance.GetBribeCount(faction) + " = " + cost);
int silver = TradeUtility.AllLaunchableThings(map).Where(t => t.def == ThingDefOf.Silver).Sum(t => t.stackCount);
if (silver < cost)
{
var diaOption = new DiaOption("OfferGift".Translate() + " (" + "NeedSilverLaunchable".Translate(new object[]
{
cost
}) + ")");
diaOption.Disable("NotEnoughSilver".Translate());
return(diaOption);
}
float goodwillDelta = 12f * negotiator.GetStatValue(StatDefOf.GiftImpact);
var diaOption2 = new DiaOption("OfferGift".Translate() + " (" + "SilverForGoodwill".Translate(new object[]
{
cost,
goodwillDelta.ToString("#####0")
}) + ")");
diaOption2.action = delegate
{
TradeUtility.LaunchThingsOfType(ThingDefOf.Silver, cost, map, null);
faction.AffectGoodwillWith(Faction.OfPlayer, goodwillDelta);
Hospitality_MapComponent.Instance(map).Bribe(faction);
};
string text = "SilverGiftSent".Translate(new object[]
{
faction.Name,
Mathf.RoundToInt(goodwillDelta)
});
diaOption2.link = new DiaNode(text)
{
options =
{
new DiaOption("OK".Translate())
{
linkLateBind = () => Source.FactionDialogFor(negotiator, faction)
}
}
};
return(diaOption2);
}
public static bool CanUpgradeRawMaterials(Faction faction, List <Thing> requirements, int level)
{
requirements.Clear();
Thing silver = ThingMaker.MakeThing(ThingDefOf.Silver);
switch (level)
{
case 0:
silver.stackCount = 2000;
requirements.Add(silver);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount))
{
return(true);
}
return(false);
case 1:
silver.stackCount = 3000;
requirements.Add(silver);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount))
{
return(true);
}
return(false);
case 2:
silver.stackCount = 4000;
requirements.Add(silver);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount))
{
return(true);
}
return(false);
case 3:
silver.stackCount = 5000;
requirements.Add(silver);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount))
{
return(true);
}
return(false);
default:
return(false);
}
}
public static DiaNode MakeExtortionAcceptedNode(ProblemWorker_Hacker problemWorker)
{
return(new DiaNode("ProblemHackerExtortionAccepted".Translate())
{
text = "ProblemHackerExtortionAcceptedText".Translate(problemWorker.hacker.Name),
options =
{
new DiaOption("(" + "Disconnect".Translate() + ")")
{
resolveTree = true,
action = delegate{
TradeUtility.LaunchSilver(problemWorker.rootMap, problemWorker.currentExtortionAmount);
}
}
}
});
}
public void GiveSoldThingToPlayer(Thing toGive, int countToGive, Pawn playerNegotiator)
{
if (toGive as Pawn != null)
{
Log.Error("Slave trade with a remnant colony is not supported!");
return;
}
if (playerNegotiator.Map == null)
{
Log.Error("Trade with a remnant colony is expected to take place via a com console and not via caravans!");
return;
}
Thing thing = toGive.SplitOff(countToGive);
thing.PreTraded(TradeAction.PlayerBuys, playerNegotiator, this);
TradeUtility.SpawnDropPod(DropCellFinder.TradeDropSpot(playerNegotiator.Map), playerNegotiator.Map, thing);
}
public static int GetGoodwillChange(IEnumerable <IThingHolder> pods, SettlementBase giveTo)
{
float num = 0f;
foreach (IThingHolder thingHolder in pods)
{
ThingOwner directlyHeldThings = thingHolder.GetDirectlyHeldThings();
for (int i = 0; i < directlyHeldThings.Count; i++)
{
float priceFactorSell_TraderPriceType = (giveTo.TraderKind == null) ? 1f : giveTo.TraderKind.PriceTypeFor(directlyHeldThings[i].def, TradeAction.PlayerSells).PriceMultiplier();
float tradePriceImprovementOffsetForPlayer = giveTo.TradePriceImprovementOffsetForPlayer;
float pricePlayerSell = TradeUtility.GetPricePlayerSell(directlyHeldThings[i], priceFactorSell_TraderPriceType, 1f, tradePriceImprovementOffsetForPlayer);
num += FactionGiftUtility.GetGoodwillChange(directlyHeldThings[i], directlyHeldThings[i].stackCount, pricePlayerSell, giveTo.Faction);
}
}
return((int)num);
}
public static bool CanUpgradeComponents(Faction faction, List <Thing> requirements, int level)
{
requirements.Clear();
Thing silver = ThingMaker.MakeThing(ThingDefOf.Silver);
Thing steel = ThingMaker.MakeThing(ThingDefOf.Steel);
switch (level)
{
case 0:
silver.stackCount = 2000;
requirements.Add(silver);
steel.stackCount = 1600;
requirements.Add(steel);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == steel.def).Sum(t => t.stackCount) >= steel.stackCount)
{
return(true);
}
return(false);
case 1:
silver.stackCount = 4500;
requirements.Add(silver);
steel.stackCount = 2500;
requirements.Add(steel);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == steel.def).Sum(t => t.stackCount) >= steel.stackCount)
{
return(true);
}
return(false);
case 2:
silver.stackCount = 7000;
requirements.Add(silver);
steel.stackCount = 4000;
requirements.Add(steel);
if (TradeUtility.ColonyHasEnoughSilver(Find.AnyPlayerHomeMap, silver.stackCount) && TradeUtility.AllLaunchableThingsForTrade(Find.AnyPlayerHomeMap).Where(t => t.def == steel.def).Sum(t => t.stackCount) >= steel.stackCount)
{
return(true);
}
return(false);
default:
return(false);
}
}
