protected override bool TryExecuteWorker(IncidentParms parms)
{
Alliance alliance = parms.target as Alliance;
if (alliance.Factions.Count == 0)
{
return(false);
}
FactionInteraction factionInteraction = alliance.Factions.RandomElement();
if (!Find.WorldObjects.Settlements.Where(x => x.Faction == factionInteraction.Faction &&
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(Find.AnyPlayerHomeMap.Tile, x.Tile, null).TicksToDays() < 7).TryRandomElement(out Settlement settlement))
{
return(false);
}
var research = Find.ResearchManager.currentProj;
int pointsReward = (int)((research.baseCost - Find.ResearchManager.GetProgress(research)) * 0.3f);
Alliance_Quest_ResearchSharing quest = new Alliance_Quest_ResearchSharing(factionInteraction.Faction, SkillDef, pointsReward);
quest.id = QuestsManager.Communications.UniqueIdManager.GetNextQuestID();
quest.TicksToPass = 6 * 60000;
quest.IncidentDef = def;
QuestSite questSite = quest.CreateSiteFor(settlement.Tile, quest.Faction);
Find.WorldObjects.Add(questSite);
QuestsManager.Communications.AddQuest(quest, null);
SendStandardLetter(parms, questSite, factionInteraction.Faction.Name, pointsReward.ToString());
return(true);
}
static void Postfix(Caravan __instance, ref bool __result)
{
if (!__instance.IsHashIntervalTick(60))
{
__result = Base.Instance.cachedResult;
return;
}
if (Base.Instance.GetExtendedDataStorage() is ExtendedDataStorage store)
{
if (store.GetExtendedDataFor(__instance) is ExtendedCaravanData data)
{
if (data.forceRest)
{
__result = true;
}
if (data.fullyIgnoreRest)
{
__result = false;
}
if (data.almostThere)
{
var estimatedTicks = (float)CaravanArrivalTimeEstimator.EstimatedTicksToArrive(__instance, allowCaching: true);
var restTicksLeft = CaravanNightRestUtility.LeftRestTicksAt(__instance.Tile, Find.TickManager.TicksAbs);
estimatedTicks -= restTicksLeft;
if (estimatedTicks / GenDate.TicksPerHour < Base.almostThereHours.Value)
{
__result = false;
}
}
}
}
Base.Instance.cachedResult = __result;
}
public override void Notify_CaravanFormed(QuestSite site, Caravan caravan)
{
foreach (var pawn in savedPawns)
{
if (pawn != null && !pawn.Dead)
{
caravan.AddPawn(pawn, false);
pawn.DestroyOrPassToWorld();
}
}
saved = true;
ResetIcon();
Settlement settlement = Find.WorldObjects.Settlements.Where(delegate(Settlement settl)
{
return(settl.Faction == Faction && Find.WorldReachability.CanReach(site.Tile, settl.Tile));
}).OrderBy(x => Find.WorldGrid.ApproxDistanceInTiles(site.Tile, x.Tile)).FirstOrDefault();
if (settlement != null)
{
int arrivalTime = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(site.Tile, settlement.Tile, caravan);
TicksToPass = arrivalTime + (3 * 60000);
UnlimitedTime = false;
Find.LetterStack.ReceiveLetter("Quest_MissingPeople_Stage2Title".Translate(), "Quest_MissingPeople_Stage2".Translate(TicksToPass.ToStringTicksToDays("0.#")), LetterDefOf.PositiveEvent);
site.Tile = settlement.Tile;
Target = new LookTargets(site.Tile);
}
Current.Game.DeinitAndRemoveMap(site.Map);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map;
if (!this.TryGetRandomAvailableTargetMap(out map))
{
return(false);
}
SettlementBase settlementBase = IncidentWorker_QuestTradeRequest.RandomNearbyTradeableSettlement(map.Tile);
if (settlementBase == null)
{
return(false);
}
TradeRequestComp component = settlementBase.GetComponent <TradeRequestComp>();
if (!this.TryGenerateTradeRequest(component, map))
{
return(false);
}
string text = "LetterCaravanRequest".Translate(new object[]
{
settlementBase.Label,
TradeRequestUtility.RequestedThingLabel(component.requestThingDef, component.requestCount).CapitalizeFirst(),
(component.requestThingDef.GetStatValueAbstract(StatDefOf.MarketValue, null) * (float)component.requestCount).ToStringMoney("F0"),
GenThing.ThingsToCommaList(component.rewards, true, true, -1).CapitalizeFirst(),
GenThing.GetMarketValue(component.rewards).ToStringMoney("F0"),
(component.expiration - Find.TickManager.TicksGame).ToStringTicksToDays("F0"),
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(map.Tile, settlementBase.Tile, null).ToStringTicksToDays("0.#")
});
GenThing.TryAppendSingleRewardInfo(ref text, component.rewards);
Find.LetterStack.ReceiveLetter("LetterLabelCaravanRequest".Translate(), text, LetterDefOf.PositiveEvent, settlementBase, settlementBase.Faction, null);
return(true);
}
public void MoveWorkersToNextLeg(int fromTile)
{
RoadConstructionLeg nextLeg = GetNextLeg();
if (nextLeg != null)
{
List <Caravan> CaravansWorkingHere = new List <Caravan>();
Find.WorldObjects.GetPlayerControlledCaravansAt(fromTile, CaravansWorkingHere);
foreach (Caravan c in CaravansWorkingHere) // Move to the nextLeg all caravans that are currently set to work on this site
{
if (c.GetComponent <WorldObjectComp_Caravan>().getSite() == this)
{
c.pather.StartPath(Tile, new CaravanArrivalAction_StartWorkingOnRoad());
}
}
if (helpFromFaction != null) // Delay when the help starts on the next leg by as many ticks as it would take a caravan to travel from the site to the next leg
{
int delay = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(fromTile, Tile, null);
if (helpFromTick > Find.TickManager.TicksGame)
{
helpFromTick += delay;
}
else
{
helpFromTick = Find.TickManager.TicksGame + delay;
}
}
}
}
private void RecreatePaths()
{
ReleasePaths();
for (int i = 1; i < waypoints.Count; i++)
{
paths.Add(WorldVehiclePathfinder.Instance.FindPath(waypoints[i - 1].Tile, waypoints[i].Tile, vehicles, null));
}
cachedTicksToWaypoint.Clear();
int num = 0;
int caravanTicksPerMove = CaravanTicksPerMove;
for (int j = 0; j < waypoints.Count; j++)
{
if (j == 0)
{
cachedTicksToWaypoint.Add(0);
}
else
{
num += CaravanArrivalTimeEstimator.EstimatedTicksToArrive(waypoints[j - 1].Tile, waypoints[j].Tile, paths[j - 1], 0f, caravanTicksPerMove, GenTicks.TicksAbs + num);
cachedTicksToWaypoint.Add(num);
}
}
}
public static float GetTravelDays(Faction faction, Map map)
{
if (travelDaysCache.TryGetValue(faction, out var minTicks))
{
return(minTicks / (float)GenDate.TicksPerDay);
}
minTicks = Int32.MaxValue;
foreach (var settlement in Find.WorldObjects.SettlementBases)
{
if (settlement.Faction != faction)
{
continue;
}
int travelTicks = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(map.Tile, settlement.Tile, null);
if (travelTicks <= 0)
{
continue;
}
if (travelTicks < minTicks)
{
minTicks = travelTicks;
}
}
if (minTicks == Int32.MaxValue)
{
return(NoBasesLeft);
}
travelDaysCache.Add(faction, minTicks);
//Log.Message("It takes the " + faction.def.pawnsPlural + " " + days + " days to travel to the player.");
return(minTicks / (float)GenDate.TicksPerDay);
}
public SettlementInfo ClosestSettlementOfFaction(Faction faction)
{
InitListOfSettlements();
var travelTicks = maxTicksToNeighbour;
SettlementInfo closestSettlement = null;
if (listOfSettlements == null)
{
return(null);
}
foreach (var si in listOfSettlements)
{
if (si.settlement.Faction != faction)
{
continue;
}
var travelTicksFromHere =
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(si.settlement.Tile, Tile, null);
if (travelTicksFromHere >= travelTicks)
{
continue;
}
closestSettlement = si;
travelTicks = travelTicksFromHere;
}
return(closestSettlement);
}
public static int EstimatedTicksToArrive(int from, int to, int ticksPerMove)
{
using (WorldPath worldPath = Verse.Find.WorldPathFinder.FindPath(from, to, null))
{
if (!worldPath.Found)
{
return(0);
}
return(CaravanArrivalTimeEstimator.EstimatedTicksToArrive(from, to, worldPath, 0, ticksPerMove, Verse.Find.TickManager.TicksAbs));
}
}
public void SelectNewFaction(FactionInteraction faction)
{
factionInteraction = faction;
factionSettlements = Find.WorldObjects.Settlements.Where(x => x.Faction == factionInteraction.Faction)
.ToDictionary(k => k, v => CaravanArrivalTimeEstimator.EstimatedTicksToArrive(Find.AnyPlayerHomeMap.Tile, v.Tile, null).TicksToDays());
SelectNewSettlement(factionSettlements.First().Key);
UpdateDeliveryMethod();
}
private static void DetermineCaravanTravelTimeFromFaction(Faction faction, Map playerMap)
{
try
{
var radius = 60;
var playerBase = playerMap.Tile;
var grid = Find.World.grid;
var bases = Find.WorldObjects.SettlementBases.FindAll(settlementBase =>
settlementBase.Faction.Name == faction.Name);
var closestFactionBase = 0;
var ticksToArrive = int.MaxValue;
bases.ForEach(fBase =>
{
if (!(grid.ApproxDistanceInTiles(playerBase, fBase.Tile) < radius))
{
return;
}
var ticks = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(
fBase.Tile,
playerBase,
Find.WorldPathFinder.FindPath(fBase.Tile, playerBase, null),
0f,
CaravanTicksPerMoveUtility.DefaultTicksPerMove,
GenTicks.TicksAbs
);
if (ticks >= ticksToArrive)
{
return;
}
ticksToArrive = ticks;
closestFactionBase = fBase.Tile;
});
if (closestFactionBase == 0)
{
Log.Error("Couldn't find faction base within " + radius + " tiles");
// Fallback travel time 3.5 days
factionTravelTime.Add(faction, Mathf.FloorToInt(3.5f * fullDayInTicks));
return;
}
factionTravelTime.Add(faction, ticksToArrive);
}
catch
{
Log.Error("Error calculating dist to nearest settlement for " + faction.Name +
". Defaulting travel time to 3.5 days");
factionTravelTime.Add(faction, Mathf.FloorToInt(3.5f * fullDayInTicks));
}
}
private int RandomOfferDuration(int tileIdFrom, int tileIdTo)
{
int num = IncidentWorker_ArcaneScriptCaravan.OfferDurationRange.RandomInRange;
int num2 = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
float num3 = (float)num2 / 60000f;
int b = Mathf.CeilToInt(Mathf.Max(num3 + 1f, num3 * 1.1f));
num = Mathf.Max(num, b);
if (num > IncidentWorker_ArcaneScriptCaravan.OfferDurationRange.max)
{
return(-1);
}
return(60000 * num);
}
protected virtual int RandomExpiryTicks()
{
var tileIdFrom = home.Tile;
var info = Targets.TryGetPrimaryTarget();
var tileIdTo = info.IsValid ? info.Tile : tileIdFrom;
var arriveTicks = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
var arriveDays = arriveTicks / 60000F;
var minDays = Mathf.CeilToInt(Mathf.Max(arriveDays + 6, arriveDays * 1.35F));
var days = Mathf.Max(ExpirationDaysRange.RandomInRange, Mathf.Min(ExpirationDaysRange.max, minDays));
return(60000 * days);
}
private static int RandomOfferDuration(int tileIdFrom, int tileIdTo)
{
int offerValidForDays = OfferDurationRange.RandomInRange;
int travelTimeByCaravan = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(@from: tileIdFrom, to: tileIdTo, caravan: null);
float daysWorthOfTravel = (float)travelTimeByCaravan / GenDate.TicksPerDay;
int b = Mathf.CeilToInt(f: Mathf.Max(a: daysWorthOfTravel + 1f, b: daysWorthOfTravel * 1.1f));
offerValidForDays = Mathf.Max(a: offerValidForDays, b: b);
if (offerValidForDays > OfferDurationRange.max)
{
return(-1);
}
return(GenDate.TicksPerDay * offerValidForDays);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
if (!settings.Active)
{
return(false);
}
Faction faction = GetFaction();
List <Settlement> factionBases = Find.WorldObjects.Settlements.Where(x => x.Faction == faction &&
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(Find.AnyPlayerHomeMap.Tile, x.Tile, null).TicksToDays() < 7).ToList();
if (factionBases.Count == 0)
{
return(false);
}
Settlement factionBase = factionBases.RandomElement();
if (Find.WorldObjects.WorldObjectAt(factionBase.Tile, QuestRim.WorldObjectDefOfLocal.QuestPlace) != null)
{
return(false);
}
Quest_ThingsHelp quest = new Quest_ThingsHelp
{
id = QuestsManager.Communications.UniqueIdManager.GetNextQuestID(),
Faction = faction
};
float marketValue = GenerateRequestItems(quest, Find.AnyPlayerHomeMap);
quest.GenerateRewards(quest.GetQuestThingFilter(), new FloatRange(marketValue * 1.3f, marketValue * 1.7f), new IntRange(3, 6), null, null);
LookTargets target = new LookTargets(factionBase.Tile);
quest.Target = target;
quest.TicksToPass = Rand.Range(12, 25) * 60000;
QuestSite questPlace = (QuestSite)WorldObjectMaker.MakeWorldObject(QuestRim.WorldObjectDefOfLocal.QuestPlace);
questPlace.Tile = factionBase.Tile;
questPlace.SetFaction(faction);
questPlace.Init(quest);
quest.Site = questPlace;
Find.WorldObjects.Add(questPlace);
QuestsManager.Communications.AddQuest(quest, QuestsManager.Communications.MakeQuestLetter(quest, description: def.description, lookTarget: target));
return(true);
}
private int RandomOfferDurationTicks(int tileIdFrom, int tileIdTo)
{
int randomInRange = SiteTuning.QuestSiteTimeoutDaysRange.RandomInRange;
int num = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
float num2 = (float)num / 60000f;
int num3 = Mathf.CeilToInt(Mathf.Max(num2 + 6f, num2 * 1.35f));
if (num3 > SiteTuning.QuestSiteTimeoutDaysRange.max)
{
return(-1);
}
int num4 = Mathf.Max(randomInRange, num3);
return(60000 * num4);
}
public static int RandomOfferDurationTicks(int tileIdFrom, int tileIdTo, out int travelTicks)
{
int randomInRange = SiteTuning.QuestSiteTimeoutDaysRange.RandomInRange;
travelTicks = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
float num = (float)travelTicks / 60000f;
int num2 = Mathf.CeilToInt(Mathf.Max(num + 6f, num * 1.35f));
if (num2 > SiteTuning.QuestSiteTimeoutDaysRange.max)
{
return(-1);
}
int num3 = Mathf.Max(randomInRange, num2);
return(60000 * num3);
}
private int RandomOfferDuration(int tileIdFrom, int tileIdTo)
{
int randomInRange = IncidentWorker_CaravanRequest.OfferDurationRange.RandomInRange;
int num = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
float num2 = (float)((float)num / 60000.0);
int b = Mathf.CeilToInt(Mathf.Max((float)(num2 + 1.0), (float)(num2 * 1.1000000238418579)));
randomInRange = Mathf.Max(randomInRange, b);
int num3 = randomInRange;
IntRange offerDurationRange = IncidentWorker_CaravanRequest.OfferDurationRange;
if (num3 > offerDurationRange.max)
{
return(-1);
}
return(60000 * randomInRange);
}
private int RandomOfferDurationTicks(int tileIdFrom, int tileIdTo)
{
int randomInRange = IncidentWorker_QuestTradeRequest.RandomDurationRangeDays.RandomInRange;
int num = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(tileIdFrom, tileIdTo, null);
float num2 = (float)num / 60000f;
int num3 = Mathf.CeilToInt(Mathf.Max(num2 + 6f, num2 * 1.35f));
int result;
if (num3 > 40)
{
result = -1;
}
else
{
int num4 = Mathf.Max(randomInRange, num3);
result = 60000 * num4;
}
return(result);
}
public void searchForSettlements(int startTile, ref List <SettlementInfo> settlementsSearched)
{
var timer = System.Diagnostics.Stopwatch.StartNew();
WorldGrid worldGrid = Find.WorldGrid;
foreach (Settlement s in Find.WorldObjects.Settlements)
{
if (worldGrid.ApproxDistanceInTiles(startTile, s.Tile) <= maxNeighbourDistance)
{
int distance = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(startTile, s.Tile, null);
if (distance <= maxTicksToNeighbour)
{
settlementsSearched.Add(new SettlementInfo(s, distance));
}
}
}
timer.Stop();
RoadsOfTheRim.DebugLog("Time spent searching for settlements : " + timer.ElapsedMilliseconds + "ms");
}
private string GetTileTip(int tile, int pathIndex)
{
int num = paths[pathIndex].NodesReversed.IndexOf(tile);
int num2;
if (num > 0)
{
num2 = paths[pathIndex].NodesReversed[num - 1];
}
else if (pathIndex < paths.Count - 1 && paths[pathIndex + 1].NodesReversed.Count >= 2)
{
num2 = paths[pathIndex + 1].NodesReversed[paths[pathIndex + 1].NodesReversed.Count - 2];
}
else
{
num2 = -1;
}
int num3 = cachedTicksToWaypoint[pathIndex] + CaravanArrivalTimeEstimator.EstimatedTicksToArrive(paths[pathIndex].FirstNode, tile, paths[pathIndex], 0f, CaravanTicksPerMove, GenTicks.TicksAbs + cachedTicksToWaypoint[pathIndex]);
int num4 = GenTicks.TicksAbs + num3;
StringBuilder stringBuilder = new StringBuilder();
if (num3 != 0)
{
stringBuilder.AppendLine("EstimatedTimeToTile".Translate(num3.ToStringTicksToDays("0.##")));
}
stringBuilder.AppendLine("ForagedFoodAmount".Translate() + ": " + Find.WorldGrid[tile].biome.forageability.ToStringPercent());
stringBuilder.Append(VirtualPlantsUtility.GetVirtualPlantsStatusExplanationAt(tile, num4));
if (num2 != -1)
{
stringBuilder.AppendLine();
stringBuilder.AppendLine();
StringBuilder stringBuilder2 = new StringBuilder();
float num5 = WorldPathGrid.CalculatedMovementDifficultyAt(num2, false, new int?(num4), stringBuilder2);
float roadMovementDifficultyMultiplier = Find.WorldGrid.GetRoadMovementDifficultyMultiplier(tile, num2, stringBuilder2);
stringBuilder.Append("TileMovementDifficulty".Translate() + ":\n" + stringBuilder2.ToString().Indented(" "));
stringBuilder.AppendLine();
stringBuilder.Append(" = ");
stringBuilder.Append((num5 * roadMovementDifficultyMultiplier).ToString("0.#"));
}
return(stringBuilder.ToString());
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Faction faction = GetFaction();
if (!Find.WorldObjects.Settlements.Where(x => x.Faction == faction &&
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(Find.AnyPlayerHomeMap.Tile, x.Tile, null).TicksToDays() < 6).TryRandomElement(out Settlement factionBase))
{
return(false);
}
List <int> neighbors = new List <int>();
Find.WorldGrid.GetTileNeighbors(factionBase.Tile, neighbors);
if (neighbors.Count == 0)
{
return(false);
}
int rebelPos = neighbors.RandomElement();
Quest_SuppressionRebellion quest = new Quest_SuppressionRebellion();
quest.id = QuestsManager.Communications.UniqueIdManager.GetNextQuestID();
quest.Faction = factionBase.Faction;
quest.TicksToPass = Rand.Range(10, 20) * 60000;
quest.GenerateRewards(quest.GetQuestThingFilter(), quest.Faction.GetRangeByFactionTechLevel(400, 700), new IntRange(3, 8), null, null);
QuestSite questSite = quest.CreateSiteFor(rebelPos, quest.Faction);
quest.RebelSettlement = factionBase;
questSite.RemoveAfterLeave = false;
Find.WorldObjects.Add(questSite);
string desc = string.Format(def.letterText, factionBase.Faction.leader.Name.ToStringFull, factionBase.Name, factionBase.Faction.Name);
QuestsManager.Communications.AddQuest(quest, QuestsManager.Communications.MakeQuestLetter(quest, description: desc, lookTarget: questSite));
return(true);
}
public SettlementInfo closestSettlementOfFaction(Faction faction)
{
initListOfSettlements();
int travelTicks = maxTicksToNeighbour;
SettlementInfo closestSettlement = null;
if (listOfSettlements != null)
{
foreach (SettlementInfo si in listOfSettlements)
{
if (si.settlement.Faction == faction)
{
int travelTicksFromHere = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(si.settlement.Tile, Tile, null);
if (travelTicksFromHere < travelTicks)
{
closestSettlement = si;
travelTicks = travelTicksFromHere;
}
}
}
}
return(closestSettlement);
}
public override string GetInspectString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.Resting)
{
stringBuilder.Append("CaravanResting".Translate());
}
else if (this.AnyPawnHasExtremeMentalBreak)
{
stringBuilder.Append("CaravanMemberMentalBreak".Translate(new object[]
{
this.FirstPawnWithExtremeMentalBreak.LabelShort
}));
}
else if (this.AllOwnersDowned)
{
stringBuilder.Append("AllCaravanMembersDowned".Translate());
}
else if (this.pather.Moving)
{
if (this.pather.arrivalAction != null)
{
stringBuilder.Append(this.pather.arrivalAction.ReportString);
}
else
{
stringBuilder.Append("CaravanTraveling".Translate());
}
}
else
{
FactionBase factionBase = CaravanVisitUtility.FactionBaseVisitedNow(this);
if (factionBase != null)
{
stringBuilder.Append("CaravanVisiting".Translate(new object[]
{
factionBase.Label
}));
}
else
{
stringBuilder.Append("CaravanWaiting".Translate());
}
}
if (this.pather.Moving)
{
stringBuilder.AppendLine();
stringBuilder.Append("CaravanEstimatedTimeToDestination".Translate(new object[]
{
CaravanArrivalTimeEstimator.EstimatedTicksToArrive(this, true).ToStringTicksToPeriod(true)
}));
}
if (this.ImmobilizedByMass)
{
stringBuilder.AppendLine();
stringBuilder.Append("CaravanImmobilizedByMass".Translate());
}
string text;
if (CaravanPawnsNeedsUtility.AnyPawnOutOfFood(this, out text))
{
stringBuilder.AppendLine();
stringBuilder.Append("CaravanOutOfFood".Translate());
if (!text.NullOrEmpty())
{
stringBuilder.Append(" ");
stringBuilder.Append(text);
stringBuilder.Append(".");
}
}
else
{
stringBuilder.AppendLine();
stringBuilder.Append("CaravanDaysOfFood".Translate(new object[]
{
this.DaysWorthOfFood.ToString("0.#")
}));
}
stringBuilder.AppendLine();
stringBuilder.AppendLine(string.Concat(new string[]
{
"CaravanBaseMovementTime".Translate(),
": ",
((float)this.TicksPerMove / 2500f).ToString("0.##"),
" ",
"CaravanHoursPerTile".Translate()
}));
double actualTicksPerMove = ((double)this.TicksPerMove / 2500f) * (2500f + WorldPathGrid.CalculatedCostAt(base.Tile, false, -1f));
stringBuilder.Append("CurrentTileMovementTime".Translate() + ": " + ((int)actualTicksPerMove).ToStringTicksToPeriod(true));
return(stringBuilder.ToString());
}
private int CalcuteTravelTimeForTrader(int originTile)
{
int travelTime = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(@from: originTile, to: this.map.Tile, caravan: null);
return(Math.Min(val1: travelTime, val2: GenDate.TicksPerDay * 4));
}
private int CalcuteTravelTimeForReinforcements(int originTile, int destinationTile)
{
return(CaravanArrivalTimeEstimator.EstimatedTicksToArrive(from: originTile, to: destinationTile, caravan: null));
}
private int CalcuteTravelTimeForTrader(int originTile)
{
var travelTime = CaravanArrivalTimeEstimator.EstimatedTicksToArrive(originTile, map.Tile, null);
return(Math.Min(travelTime, GenDate.TicksPerDay * 4));
}
private void SelectApproximateBestFoodAndMedicine()
{
IEnumerable <TransferableOneWay> enumerable = transferables.Where((TransferableOneWay x) => x.ThingDef.category != ThingCategory.Pawn && !x.ThingDef.thingCategories.NullOrEmpty() && x.ThingDef.thingCategories.Contains(ThingCategoryDefOf.Medicine));
IEnumerable <TransferableOneWay> enumerable2 = transferables.Where((TransferableOneWay x) => x.ThingDef.IsIngestible && !x.ThingDef.IsDrug && !x.ThingDef.IsCorpse);
tmpBeds.Clear();
for (int i = 0; i < transferables.Count; i++)
{
for (int j = 0; j < transferables[i].things.Count; j++)
{
Thing thing = transferables[i].things[j];
for (int k = 0; k < thing.stackCount; k++)
{
Building_Bed building_Bed;
if ((building_Bed = thing.GetInnerIfMinified() as Building_Bed) != null && building_Bed.def.building.bed_caravansCanUse)
{
for (int l = 0; l < building_Bed.SleepingSlotsCount; l++)
{
tmpBeds.Add(transferables[i]);
}
}
}
}
}
tmpBeds.SortByDescending((TransferableOneWay x) => x.AnyThing.GetStatValue(StatDefOf.BedRestEffectiveness));
foreach (TransferableOneWay item in enumerable)
{
item.AdjustTo(0);
}
foreach (TransferableOneWay item2 in enumerable2)
{
item2.AdjustTo(0);
}
foreach (TransferableOneWay tmpBed in tmpBeds)
{
tmpBed.AdjustTo(0);
}
List <Pawn> pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(transferables);
if (!pawnsFromTransferables.Any())
{
return;
}
foreach (Pawn item3 in pawnsFromTransferables)
{
TransferableOneWay transferableOneWay = BestBedFor(item3);
if (transferableOneWay != null)
{
tmpBeds.Remove(transferableOneWay);
if (transferableOneWay.CanAdjustBy(1).Accepted)
{
AddOneIfMassAllows(transferableOneWay);
}
}
if (item3.AnimalOrWildMan() || item3.guest.IsPrisoner)
{
continue;
}
for (int m = 0; m < 2; m++)
{
Transferable transferable = BestMedicineItemFor(item3, enumerable);
if (transferable != null)
{
AddOneIfMassAllows(transferable);
}
}
}
if (destinationTile == -1 || !DaysWorthOfFoodCalculator.AnyFoodEatingPawn(pawnsFromTransferables) || !enumerable2.Any())
{
return;
}
try
{
using WorldPath path = Find.WorldPathFinder.FindPath(CurrentTile, destinationTile, null);
int ticksPerMove = CaravanTicksPerMoveUtility.GetTicksPerMove(new CaravanTicksPerMoveUtility.CaravanInfo(this));
CaravanArrivalTimeEstimator.EstimatedTicksToArriveToEvery(CurrentTile, destinationTile, path, 0f, ticksPerMove, Find.TickManager.TicksAbs, tmpTicksToArrive);
float num = (float)tmpTicksToArrive.Last().Second / 60000f + 4f;
float num2;
bool flag;
do
{
num2 = DaysWorthOfFoodCalculator.ApproxDaysWorthOfFood(transferables, CurrentTile, IgnoreInventoryMode, Faction.OfPlayer, path, 0f, ticksPerMove);
if (num2 >= num)
{
break;
}
flag = false;
foreach (Pawn item4 in pawnsFromTransferables)
{
Transferable transferable2 = BestFoodItemFor(item4, enumerable2, tmpTicksToArrive);
if (transferable2 != null && AddOneIfMassAllows(transferable2))
{
flag = true;
}
}
}while (flag && num2 < num && MassUsage < MassCapacity);
}
finally
{
tmpTicksToArrive.Clear();
daysWorthOfFoodDirty = true;
massUsageDirty = true;
}
}
