public static void Postfix(ref Zone_Growing __instance, ref string __result)
{
var plantDef = __instance.GetPlantDefToGrow();
var thePlant = plantDef.plant;
int totalYield = 0, maxYield = 0, num = 0, numGrowing = 0;
float totalGrowthRemaining = 0f;
foreach (Thing thing in __instance.AllContainedThings)
{
if (thing.def == plantDef && thing is Plant plant)
{
++num;
totalYield += plant.YieldNow();
if (plant.Growth < 0.95f && !plant.YIResting() && plant.GrowthRateFactor_Light > .001f)
{
++numGrowing;
totalGrowthRemaining += plant.YIActualGrowthTime();
}
}
}
maxYield = (int)thePlant.harvestYield;
float efficiency = maxYield / thePlant.growDays;
__result += "\n" + "YI.InspectYields".Translate(new object[] { totalYield.ToString(), (maxYield * num).ToString() });
__result += "\n" + "YI.Efficiency".Translate(efficiency.ToString("0.##"));
// If is resting period, we dont show the line.
if (GenLocalDate.DayPercent(__instance.Map) < 0.25f || GenLocalDate.DayPercent(__instance.Map) > 0.8f)
{
__result += "\n" + "YI.GrowthRemaining".Translate((totalGrowthRemaining / numGrowing).ToString("0.##"));
}
}
private static IEnumerable <Gizmo> AddGizmos(Zone_Growing __instance, IEnumerable <Gizmo> __result)
{
foreach (var gizmo in __result)
{
yield return(gizmo);
}
if (tw_YAAM.ConvertSoilAfterHarvest)
{
yield return new Command_Toggle
{
defaultLabel = "twYAAM_PlaceBlueprint_Title".Translate(),
defaultDesc = "twYAAM_PlaceBlueprint_Description".Translate(),
icon = ContentFinder <Texture2D> .Get("PlaceBlueprintUI"),
isActive = () => tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Contains(__instance.label),
toggleAction = delegate {
if (tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Contains(__instance.label))
{
tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Remove(__instance.label);
}
else
{
tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Add(__instance.label);
}
}
}
}
;
yield return(new Terrain_Action(__instance, TerrainDefOf.twSoilTilled));
yield return(new Terrain_Action(__instance, TerrainDefOf.twSoilEnriched));
yield return(new Terrain_Action(__instance, TerrainDefOf.twSoilFertilized));
}
}
private static void Postfix(Zone_Growing __instance, ref string __result)
{
var data = __instance.GetFarmingHysteresisData();
var(harvestedThingDef, harvestedThingCount) = __instance.PlantHarvestInfo();
if (data.Enabled)
{
if (harvestedThingDef == null)
{
data.DisableDueToMissingHarvestedThingDef(__instance);
return;
}
var plant = __instance.GetPlantDefToGrow();
__result += "\n" + "FarmingHysteresis.UseGlobalBounds".Translate(harvestedThingDef.label, data.useGlobalValues ? "Yes".Translate() : "No".Translate());
__result += "\n" + "FarmingHysteresis.LowerBound".Translate(plant.label, data.LowerBound, harvestedThingDef.label);
__result += "\n" + "FarmingHysteresis.UpperBound".Translate(plant.label, data.UpperBound, harvestedThingDef.label);
__result += "\n" + "FarmingHysteresis.InStorage".Translate(harvestedThingDef.label, harvestedThingCount);
__result += "\n" + "FarmingHysteresis.LatchModeDesc".Translate(("FarmingHysteresis.LatchModeDesc." + data.latchMode.ToString()).Translate());
}
else if (harvestedThingDef == null)
{
__result += "\n" + "FarmingHysteresis.DisabledDueToMissingHarvestedThingDef".Translate();
}
}
protected override Option <Thing> TargetThing()
{
Zone_Growing z = (this.Position + this.Rotation.Opposite.FacingCell)
.GetZone(this.Map) as Zone_Growing;
if (z == null)
{
return(Nothing <Thing>());
}
if (this.takeForbiddenItems)
{
return(z.AllContainedThings
.Where(t => t.def.category == ThingCategory.Item)
.Where(t => this.settings.AllowedToAccept(t))
.Where(t => !this.IsLimit(t))
.FirstOption());
}
else
{
return(z.AllContainedThings
.Where(t => t.def.category == ThingCategory.Item)
.Where(t => !t.IsForbidden(Faction.OfPlayer))
.Where(t => this.settings.AllowedToAccept(t))
.Where(t => !this.IsLimit(t))
.FirstOption());
}
}
public override string GetInspectString()
{
string text = string.Empty;
if (!base.Cells.NullOrEmpty <IntVec3>())
{
IntVec3 c = base.Cells.First <IntVec3>();
if (c.UsesOutdoorTemperature(base.Map))
{
string text2 = text;
text = string.Concat(new string[]
{
text2,
"OutdoorGrowingPeriod".Translate(),
": ",
Zone_Growing.GrowingQuadrumsDescription(base.Map.Tile),
"\n"
});
}
if (PlantUtility.GrowthSeasonNow(c, base.Map, true))
{
text += "GrowSeasonHereNow".Translate();
}
else
{
text += "CannotGrowBadSeasonTemperature".Translate();
}
}
return(text);
}
private static void Postfix(ref Zone_Growing __instance)
{
var allowTill = TillToggle.IsAllowed(__instance);
Scribe_Values.Look(ref allowTill, "allowTill", true);
TillToggle.SetAllowed(__instance, allowTill);
}
static void Prefix(Zone_Growing __instance)
{
if (tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Contains(__instance.label))
{
tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Remove(__instance.label);
}
}
private static void Postfix(ref Zone_Growing __instance)
{
var allowHarvest = Mod.IsAllowed(__instance);
Scribe_Values.Look(ref allowHarvest, "allowHarvest", true);
Mod.SetAllowed(__instance, allowHarvest);
}
protected override void GetAffectedThings()
{
int curTick = Find.TickManager.TicksGame;
if (lastTick + 10 > curTick)
{
return;
}
else
{
this.numAffectedZones = 0;
foreach (Map map in Find.Maps)
{
foreach (Zone z in map.zoneManager.AllZones)
{
if (z is Zone_Growing)
{
Zone_Growing zg = (Zone_Growing)z;
if (!zg.allowSow)
{
this.numAffectedZones++;
}
}
}
}
lastTick = curTick;
}
}
public static void Postfix(ref IEnumerable <Gizmo> __result, Zone_Growing __instance)
{
var list = __result.ToList();
Priority priority = PriorityTracker.growingZonePriorities.TryGetValue(__instance, out PriorityIntHolder intp) ? (Priority)intp.Int : Priority.Normal;
list.Add(new Command_GrowingPriority((int)priority)
{
defaultLabel = $"Priority {priority}",
defaultDesc = $"Set this growing zone's priority. Current priority = {priority}",
icon = TexCommand.ForbidOff,
onChanged = (x) => {
var p = PriorityTracker.growingZonePriorities;
if (p.ContainsKey(__instance))
{
p[__instance].Int = x;
}
else
{
p[__instance] = new PriorityIntHolder(x);
}
}
});
__result = list;
}
//public override IEnumerable<Gizmo> GetGizmos()
static void Postfix(Zone_Growing __instance, ref IEnumerable <Gizmo> __result)
{
if (!Mod.settings.zoneHarvestableToggle)
{
return;
}
List <Gizmo> result = new List <Gizmo>(__result);
Gizmo harvestGizmo = new Command_Toggle
{
defaultLabel = "TD.AllowHarvesting".Translate(),
defaultDesc = "TD.AllowHarvestingDesc".Translate(),
icon = ContentFinder <UnityEngine.Texture2D> .Get("UI/Designators/Harvest", true),
isActive = (() => __instance.CanHarvest()),
toggleAction = delegate
{
__instance.ToggleHarvest();
}
};
result.Add(harvestGizmo);
// make caller use the list
__result = result.AsEnumerable();
}
protected override Thing TargetThing()
{
Zone_Growing z = (this.Position + this.Rotation.Opposite.FacingCell)
.GetZone(this.Map) as Zone_Growing;
Thing target;
if (z == null)
{
return(null);
}
target = z.AllContainedThings
.Where(t => t.def.category == ThingCategory.Item)
.Where(t => !t.IsForbidden(Faction.OfPlayer) || this.takeForbiddenItems)
.Where(t => this.settings.AllowedToAccept(t))
.Where(t => !this.IsLimit(t)).FirstOrDefault <Thing>();
if (target == null)
{
return(target);
}
if (this.takeSingleItems)
{
return(target.SplitOff(1));
}
// SplitOff ensures any item-removal effects happen:
return(target.SplitOff(target.stackCount));
}
public static void Postfix(ref IEnumerable <Gizmo> __result, Zone_Growing __instance)
{
var priority = PriorityTracker.growingZonePriorities.TryGetValue(__instance, out var intp)
? (Priority)intp.Int
: Priority.Normal;
__result = __result.Append(new Command_GrowingPriority(priority));
}
static void Postfix(ref IEnumerable <Gizmo> __result, Zone_Growing __instance)
{
HarvestManager_MapComponent manager = __instance.Map.GetComponent <HarvestManager_MapComponent>();
Gizmo setMode = new Command_SetHarvestMode(__instance, manager);
Gizmo setProportion = new Command_SetHarvestProportion(__instance, manager);
__result = AppendGizmoToEnumerable(__result, setMode);
__result = AppendGizmoToEnumerable(__result, setProportion);
}
public static void Postfix(Zone_Growing __instance)
{
if (!PriorityTracker.growingZonePriorities.ContainsKey(__instance))
{
PriorityTracker.growingZonePriorities[__instance] = new PriorityIntHolder((int)Priority.Normal);
}
Scribe_Values.Look <int>(ref PriorityTracker.growingZonePriorities[__instance].Int, "growingPriority", (int)Priority.Normal, false);
}
public static void SetPlantDefToGrow(Zone_Growing __instance, ThingDef plantDef)
{
if (Current.ProgramState == ProgramState.Playing)
{
foreach (IntVec3 c in __instance.cells)
{
PlantSowing_Cache.ReregisterObject(__instance.Map, c, WorkGiver_Grower_Patch.awaitingPlantCellsMapDict);
}
}
}
public static void ToggleHarvest(this Zone_Growing zone)
{
if (zone.Map.GetComponent <MapComponent_ZoneForbidHarvest>().harvestForbidden.Contains(zone))
{
zone.Map.GetComponent <MapComponent_ZoneForbidHarvest>().harvestForbidden.Remove(zone);
}
else
{
zone.Map.GetComponent <MapComponent_ZoneForbidHarvest>().harvestForbidden.Add(zone);
}
}
public static void SetAllowed(Zone_Growing zone, bool allowed)
{
if (!allowed && IsAllowed(zone))
{
AllowedZones.Remove(zone);
}
else if (allowed && !IsAllowed(zone))
{
AllowedZones.Add(zone);
}
}
public void Clear()
{
zone = null;
totalPlantedCount = 0;
harvestablePlants.Clear();
fullyGrownPlants.Clear();
for (int i = 0; i < 101; i++)
{
growRatesAbsolute[i] = 0;
}
}
public static bool prefix(ThingDef plantDef, Zone_Growing __instance)
{
if (use_native)
{
return(true);
}
else
{
parrot(plantDef, __instance);
return(false);
}
}
public static void parrot(ThingDef plantDef, Zone_Growing inst)
{
use_native = true;
try
{
inst.SetPlantDefToGrow(plantDef);
}
finally
{
use_native = false;
}
}
internal static (ThingDef, int) PlantHarvestInfo(this Zone_Growing zone)
{
var harvestedThingDef = zone.GetPlantDefToGrow().plant.harvestedThingDef;
if (harvestedThingDef != null)
{
return(harvestedThingDef, zone.Map.resourceCounter.GetCount(harvestedThingDef));
}
else
{
return(null, 0);
}
}
public static void SetAllowed(Zone_Growing zone, bool allowed)
{
var isDisallowed = DisallowedZones.Contains(zone);
if (allowed && isDisallowed)
{
DisallowedZones.Remove(zone);
}
else if (!allowed && !isDisallowed)
{
DisallowedZones.Add(zone);
}
}
static void Postfix(JobDriver_PlantHarvest __instance, Toil __result)
{
__result.initAction = delegate
{
Thing thing = __result.actor.jobs.curJob.GetTarget(TargetIndex.A).Thing;
Map map = __result.actor.Map;
map.designationManager.RemoveAllDesignationsOn(thing, false);
if (!tw_YAAM.ConvertSoilAfterHarvest)
{
return;
}
IntVec3 pos = thing.Position;
TerrainDef terrainDef = map.terrainGrid.TerrainAt(pos);
if (!terrainDef.defName.StartsWith("twSoil"))
{
return;
}
map.terrainGrid.SetTerrain(__result.actor.jobs.curJob.targetA.Cell, RimWorld.TerrainDefOf.Soil);
if (map.terrainGrid.TerrainAt(pos).defName != RimWorld.TerrainDefOf.Soil.defName)
{
Verse.Log.Warning("tw_YAMM.ConvertSoilAfterHarvest failed at " + pos.ToString());
}
List <Zone> zonesList = map.zoneManager.AllZones;
for (int j = 0; j < zonesList.Count; j++)
{
Zone_Growing growingZone = zonesList[j] as Zone_Growing;
if (growingZone == null)
{
continue;
}
if (growingZone.cells.Count == 0)
{
continue;
}
if (!growingZone.Cells.Contains(pos))
{
continue;
}
if (tw_YAAM.WorldObject.GrowingZonesPlaceBlueprint.Contains(growingZone.label))
{
Blueprint_Build blueprint_Build = GenConstruct.PlaceBlueprintForBuild(terrainDef, pos, map, Rot4.North, Faction.OfPlayer, null);
if (blueprint_Build == null)
{
Verse.Log.Warning("tw_YAMM.PlaceBlueprint failed for " + terrainDef.defName + " in " + growingZone.label);
}
return;
}
}
};
}
public override Job TryGiveJob(Pawn pawn)
{
int plantSkill = pawn.skills.GetSkill(SkillDefOf.Plants).Level;
Zone growZone = null;
if (!pawn.Map.zoneManager.AllZones.Where((Zone x) =>
{
Zone_Growing zone = x as Zone_Growing;
if (zone == null)
{
return(false);
}
if (zone.cells.Count == 0)
{
return(false);
}
if (zone.GetPlantDefToGrow() == null || zone.GetPlantDefToGrow().plant == null)
{
return(false);
}
if (plantSkill < Mathf.RoundToInt(zone.GetPlantDefToGrow().plant.sowMinSkill * 0.75f))
{
return(false);
}
return(true);
}).TryRandomElement(out growZone))
{
return(null);
}
IntVec3 position = AIUtility.FindRandomSpotInZone(pawn, growZone, true, true);
if (position != IntVec3.Invalid)
{
return(new Job(IdleJobDefOf.IdleJob_Gardening, position)
{
locomotionUrgency = modSettings.wanderMovePolicy
});
}
else
{
return(null);
}
}
public static void Postfix(Zone_Growing __instance, ref string __result)
{
if (!Settings.Get().showZoneSize)
{
return;
}
int count = __instance.cells.Count;
__result += "\n" +
String.Format("TD.SizeAndFertile".Translate(), count, count + FertilityCount(__instance))
+ "\n" +
String.Format("TD.CountToSow".Translate(), ToDoCount(__instance))
+ " " +
String.Format("TD.CountFullyGrown".Translate(), GrownCount(__instance));
}
public static int GrownCount(Zone_Growing zone)
{
Map map = zone.Map;
int ret = 0;
ThingDef plantDef = zone.GetPlantDefToGrow();
foreach (IntVec3 cell in zone.cells)
{
if (map.thingGrid.ThingsAt(cell).FirstOrDefault(t => t is Plant) is Plant p &&
p.def == plantDef && p.Growth == 1)
{
ret++;
}
}
return(ret);
}
private static void Postfix(Zone_Growing __instance, ref IEnumerable <Gizmo> __result)
{
var allowHarvestCommand = new Command_Toggle
{
defaultLabel = "ToggleHarvest.CommandAllowHarvest".Translate(),
defaultDesc = "ToggleHarvest.CommandAllowHarvestDesc".Translate(),
icon = TexCommand.ForbidOff,
isActive = () => Mod.IsAllowed(__instance),
toggleAction = () => Mod.SetAllowed(__instance, !Mod.IsAllowed(__instance))
};
__result = new List <Gizmo>(__result)
{
allowHarvestCommand
};
}
public override IEnumerable <IntVec3> PotentialWorkCellsGlobal(Pawn pawn)
{
if (!ResearchProjectDefOf.AC_Tilling.IsFinished)
{
yield break;
}
Danger maxDanger = pawn.NormalMaxDanger();
List <Zone> zonesList = pawn.Map.zoneManager.AllZones;
ReservationLayerDef layer = ReservationLayerDefOf.Floor;
for (int j = 0; j < zonesList.Count; j++)
{
Zone_Growing growZone = zonesList[j] as Zone_Growing;
if (growZone != null && TillToggle.IsAllowed(growZone))
{
if (growZone.cells.Count == 0)
{
Log.ErrorOnce("Grow zone has 0 cells: " + growZone, -563487, false);
}
else if (!growZone.ContainsStaticFire && pawn.CanReach(growZone.Cells[0], PathEndMode.OnCell, maxDanger))
{
for (int k = 0; k < growZone.cells.Count; k++)
{
IntVec3 c = growZone.cells[k];
if (pawn.Map.terrainGrid.TerrainAt(c).GetModExtension <TerrainExtension>() != null &&
pawn.Map.terrainGrid.TerrainAt(c).GetModExtension <TerrainExtension>().tillsTo != null &&
pawn.CanReach(growZone.Cells[0], PathEndMode.OnCell, maxDanger) &&
pawn.CanReserve(c, 1, -1, layer, false))
{
if (c.GetPlant(pawn.Map) != null)
{
if (!c.GetPlant(pawn.Map).sown)
{
yield return(growZone.cells[k]);
}
}
else
{
yield return(growZone.cells[k]);
}
}
}
}
}
}
yield break;
}
private static IEnumerable <IntVec3> PotentialWorkCellsGlobalIE(WorkGiver_Grower __instance, Pawn pawn)
{
Danger maxDanger = pawn.NormalMaxDanger();
List <Building> bList = pawn.Map.listerBuildings.allBuildingsColonist;
for (int j = 0; j < bList.Count; j++)
{
Building_PlantGrower building_PlantGrower = bList[j] as Building_PlantGrower;
if (building_PlantGrower == null || !__instance.ExtraRequirements(building_PlantGrower, pawn) || building_PlantGrower.IsForbidden(pawn) ||
//!pawn.CanReach(building_PlantGrower, PathEndMode.OnCell, maxDanger) ||
building_PlantGrower.IsBurning())
{
continue;
}
foreach (IntVec3 item in building_PlantGrower.OccupiedRect())
{
yield return(item);
}
wantedPlantDef = null;
}
wantedPlantDef = null;
List <Zone> zonesList = pawn.Map.zoneManager.AllZones;
for (int j = 0; j < zonesList.Count; j++)
{
Zone_Growing growZone = zonesList[j] as Zone_Growing;
if (growZone == null)
{
continue;
}
if (growZone.cells.Count == 0)
{
Log.ErrorOnce("Grow zone has 0 cells: " + growZone, -563487);
}
else if (__instance.ExtraRequirements(growZone, pawn) && !growZone.ContainsStaticFire &&
pawn.CanReach(growZone.Cells.First(), PathEndMode.OnCell, maxDanger))
{
for (int k = 0; k < growZone.cells.Count; k++)
{
yield return(growZone.cells[k]);
}
wantedPlantDef = null;
growZone = null;
}
}
wantedPlantDef = null;
}
