static void Prefix(Pawn_WorkSettings __instance)
{
//clean favourite in case of pawn reccurect to avoid overriding
var pawn = __instance.Pawn();
FavouriteManager.Get[pawn] = null;
}
public static void Postfix(Pawn_WorkSettings __instance, Pawn ___pawn, DefMap <WorkTypeDef, int> ___priorities)
{
if (___priorities != null)
{
__instance.SetPriority(BeatPrisonersDefOf.CM_Beat_Prisoners_WorkType_Break_Resistance, 0);
}
}
static void Prefix(Pawn_WorkSettings __instance, WorkTypeDef w, ref int priority)
{
__instance.Pawn().SetPriority(w, priority, null);
// TODO: find a more elegant way to stop RW complaining about bad priorities.
priority = Mathf.Min(priority, 4);
}
static void InitializeForFormerHumans([NotNull] Pawn_WorkSettings __instance, [NotNull] Pawn ___pawn)
{
if (___pawn.IsFormerHuman() && ___pawn.workSettings != null)
{
FormerHumanUtilities.InitializeWorkSettingsFor(___pawn, __instance);
}
}
static void InitializeForFormerHumans([NotNull] Pawn_WorkSettings __instance, [NotNull] Pawn ___pawn)
{
if (___pawn.IsSapientOrFeralFormerHuman())
{
FormerHumanUtilities.InitializeWorkSettingsFor(___pawn, __instance);
}
}
private static void SetPriority(Pawn_WorkSettings workSettings, WorkTypeDef workTypeDef, int priority)
{
if (pfi == null)
{
pfi = typeof(Pawn_WorkSettings).GetField("priorities", BindingFlags.Instance | BindingFlags.NonPublic);
}
((DefMap <WorkTypeDef, int>)pfi.GetValue(workSettings))[workTypeDef] = priority;
}
public static void WorkGiversDirtySet(this Pawn_WorkSettings p, bool value)
{
if (_workGiversDirty == null)
{
_workGiversDirty = typeof(Pawn_WorkSettings).GetField("workGiversDirty", BindingFlags.Instance | BindingFlags.NonPublic);
}
_workGiversDirty.SetValue(p, value);
}
public static bool WorkGiversDirtyGet(this Pawn_WorkSettings p)
{
if (_workGiversDirty == null)
{
_workGiversDirty = typeof(Pawn_WorkSettings).GetField("workGiversDirty", BindingFlags.Instance | BindingFlags.NonPublic);
}
return((bool)_workGiversDirty.GetValue(p));
}
public static Pawn Pawn(this Pawn_WorkSettings p)
{
if (_pawn == null)
{
_pawn = typeof(Pawn_WorkSettings).GetField("pawn", BindingFlags.Instance | BindingFlags.NonPublic);
}
return((Pawn)_pawn.GetValue(p));
}
public static DefMap <WorkTypeDef, int> Priorities(this Pawn_WorkSettings p)
{
if (_priorities == null)
{
_priorities = typeof(Pawn_WorkSettings).GetField("priorities", BindingFlags.Instance | BindingFlags.NonPublic);
}
return((DefMap <WorkTypeDef, int>)_priorities.GetValue(p));
}
public static void ConfirmInitializedDebug(this Pawn_WorkSettings p)
{
if (_ConfirmInitializedDebug == null)
{
_ConfirmInitializedDebug = typeof(Pawn_WorkSettings).GetMethod("ConfirmInitializedDebug", BindingFlags.Instance | BindingFlags.NonPublic);
}
_ConfirmInitializedDebug.Invoke(p, null);
}
public static void Postfix(Pawn_WorkSettings __instance, ref int __result, Pawn ___pawn)
{
if (___pawn.kindDef == MeeseeksDefOf.MeeseeksKind)
{
__result = Pawn_WorkSettings.DefaultPriority;
//Logger.MessageFormat(__instance, "Forcing default work priority of: {0}", __result);
}
}
private void trainPawnDone(String def)
{
PawnGenerationRequest request = new PawnGenerationRequest(DefDatabase <PawnKindDef> .GetNamed(def, true), Faction.OfPlayer, PawnGenerationContext.NonPlayer, -1, false, false, false, false, true, true, 1f, false, true, true, false, false, false, false, null, null, null, null, null, null, null);
Pawn item = PawnGenerator.GeneratePawn(request);
Pawn_StoryTracker ps = item.story;
ps.childhood = null;
ps.adulthood = null;
ps.traits.allTraits = new List <Trait>();
ps.traits.GainTrait(new Trait(DefDatabase <TraitDef> .GetNamed("ra2_MakeSoldier", true)));
ps.traits.GainTrait(new Trait(TraitDefOf.Psychopath));
Pawn_WorkSettings pws = item.workSettings;
pws.DisableAll();
Pawn_PlayerSettings pps = item.playerSettings;
pps.hostilityResponse = HostilityResponseMode.Attack;
NameTriple triple = NameTriple.FromString(item.kindDef.label.Replace(" ", ""));
item.Name = triple;
item.inventory.DestroyAll();
YuriSoldierMakeUp.tryMakeUp(item);
SoundStarter.PlayOneShotOnCamera(DefDatabase <SoundDef> .GetNamed(this.parent.def.defName + "_UnitReady", true));
IntVec3 loc = CellFinder.RandomClosewalkCellNear(this.parent.Position, this.parent.Map, 3, null);
Pawn pp;
if (this.trainPawns[0] != "ra2_AlliedTanya")
{
pp = (Pawn)(GenSpawn.Spawn(item, loc, this.parent.Map, WipeMode.Vanish));
}
else
{
// bool flag = true;
if (getAllTanya().Count > 0)
{
foreach (Pawn tanya in getAllTanya())
{
tanya.Destroy(DestroyMode.Vanish);
}
}
pp = (Pawn)(GenSpawn.Spawn(getTanya(), loc, this.parent.Map, WipeMode.Vanish));
}
this.trainPawns.Remove(this.trainPawns[0]);
this.ticks = 0;
}
static void Postfix(Pawn_WorkSettings __instance, object __state, WorkTypeDef w)
{
if (__state != null)
{
DefMap <WorkTypeDef, int> pawnPriorities = AccessTools.Field(typeof(Pawn_WorkSettings), "priorities").GetValue(__instance) as DefMap <WorkTypeDef, int>;
pawnPriorities[w] = (int)__state;
}
}
private static void CheckForDisabledTypes(Pawn_WorkSettings _this, Pawn pawn)
{
foreach (var workTypeDef in WorkTypeDefsUtility.WorkTypeDefsInPriorityOrder)
{
if (pawn.story.WorkTypeIsDisabled(workTypeDef))
{
_this.Disable(workTypeDef);
}
}
}
public static bool CacheWorkGiversInOrder(Pawn_WorkSettings __instance)
{
//Pawn_WorkSettings.wtsByPrio.Clear();
List <WorkTypeDef> wtsByPrio = new List <WorkTypeDef>(); //ADD
List <WorkTypeDef> defsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
int num1 = 999;
for (int index = 0; index < defsListForReading.Count; ++index)
{
WorkTypeDef w = defsListForReading[index];
int priority = __instance.GetPriority(w);
if (priority > 0)
{
if (priority < num1 && w.workGiversByPriority.Any(wg => !wg.emergency))
{
num1 = priority;
}
wtsByPrio.Add(w); //FIND REPLACE
}
}
//FIND REPLACE
wtsByPrio.InsertionSort((a, b) =>
{
float num2 = a.naturalPriority + (4 - __instance.GetPriority(a)) * 100000;
return(((float)(b.naturalPriority + (4 - __instance.GetPriority(b)) * 100000)).CompareTo(num2));
});
WorkGiverListClear(workGiversInOrderEmerg(__instance));
for (int index1 = 0; index1 < wtsByPrio.Count; ++index1) //FIND REPLACE
{
WorkTypeDef workTypeDef = wtsByPrio[index1]; ////FIND REPLACE
for (int index2 = 0; index2 < workTypeDef.workGiversByPriority.Count; ++index2)
{
WorkGiver worker = workTypeDef.workGiversByPriority[index2].Worker;
if (worker.def.emergency && __instance.GetPriority(worker.def.workType) <= num1)
{
WorkGiverListAdd(workGiversInOrderEmerg(__instance), worker);
}
}
}
WorkGiverListClear(workGiversInOrderNormal(__instance));
for (int index1 = 0; index1 < wtsByPrio.Count; ++index1) //FIND REPLACE
{
WorkTypeDef workTypeDef = wtsByPrio[index1]; //FIND REPLACE
for (int index2 = 0; index2 < workTypeDef.workGiversByPriority.Count; ++index2)
{
WorkGiver worker = workTypeDef.workGiversByPriority[index2].Worker;
if (!worker.def.emergency || __instance.GetPriority(worker.def.workType) > num1)
{
WorkGiverListAdd(workGiversInOrderNormal(__instance), worker);
}
}
}
workGiversDirty(__instance) = false;
return(false);
}
private static void UpdatePriorities(Pawn_WorkSettings __instance)
{
var fieldInfo =
typeof(Pawn_WorkSettings).GetField("pawn", BindingFlags.NonPublic | BindingFlags.Instance);
var pawn = (Pawn)fieldInfo?.GetValue(__instance);
if (pawn != null)
{
pawn.GetSaveablePawn().ForceStatUpdate = true;
}
}
//TODO Finding a good way to Cache pawn.workSettings may increase performence
public override Job TryGiveJob()
{
Job result = null;
if (!(cachedSleepTimeList.Contains(GenLocalDate.HourOfDay(this).ToString())))
{
//Only plausibel enhancment would be to cache the pawn
//MakeDrone Average time of 1ms
Pawn pawn = MakeDrone();
//Spawn is cheap
GenSpawn.Spawn(pawn, Position, Map);
if (workSettings == null)
{
//This case takes an Average of 3.31ms
pawn.workSettings = new Pawn_WorkSettings(pawn);
pawn.workSettings.EnableAndInitialize();
pawn.workSettings.DisableAll();
workSettings = pawn.workSettings;
}
else
{
pawn.workSettings = workSettings;
}
//This loop is cheap
//Set the workSettings based upon the settings
foreach (WorkTypeDef def in WorkSettings.Keys)
{
if (WorkSettings[def])
{
pawn.workSettings.SetPriority(def, 3);
}
else
{
pawn.workSettings.SetPriority(def, 0);
}
}
//Each call to TryIssueJobPackageDrone takes an Average of 1ms
result = TryIssueJobPackageDrone(pawn, true).Job;
if (result == null)
{
result = TryIssueJobPackageDrone(pawn, false).Job;
}
pawn.Destroy();
Notify_DroneGained();
}
return(result);
}
public static Pawn Pawn(this Pawn_WorkSettings worksettings)
{
if (pawnFieldInfo == null)
{
pawnFieldInfo = typeof(Pawn_WorkSettings).GetField("pawn", AccessTools.all);
if (pawnFieldInfo == null)
{
throw new NullReferenceException("could not get pawn field");
}
}
return(pawnFieldInfo.GetValue(worksettings) as Pawn);
}
private Pawn getTanya()
{
PawnGenerationRequest request = new PawnGenerationRequest(DefDatabase <PawnKindDef> .GetNamed("ra2_AlliedTanya", true), Faction.OfPlayer, PawnGenerationContext.NonPlayer, -1, false, false, false, false, true, true, 1f, false, true, true, false, false, false, false, null, null, null, null, null, Gender.Female, null, null);
Pawn item = PawnGenerator.GeneratePawn(request);
Pawn_StoryTracker ps = item.story;
HairDef hair = DefDatabase <HairDef> .GetNamed("Curly");
ps.childhood = null;
ps.adulthood = null;
ps.traits.allTraits = new List <Trait>();
ps.traits.GainTrait(new Trait(DefDatabase <TraitDef> .GetNamed("ra2_MakeSoldier", true)));
ps.traits.GainTrait(new Trait(TraitDefOf.Psychopath));
Pawn_WorkSettings pws = item.workSettings;
pws.DisableAll();
NameTriple triple = NameTriple.FromString(item.kindDef.label);
triple.ResolveMissingPieces("Adams".Translate());
item.Name = triple;
Pawn_SkillTracker skt = item.skills;
foreach (SkillRecord sr in skt.skills)
{
sr.Level = 20;
}
item.inventory.DestroyAll();
ps.bodyType = BodyTypeDefOf.Female;
ps.hairDef = hair;
ps.hairColor = new UnityEngine.Color(1, 0.8f, 0);
//st.SkinColor = new UnityEngine.Color(0.98f,0.76f,0.71f);
ps.melanin = 0f;
Pawn_EquipmentTracker pe = item.equipment;
pe.Remove(pe.Primary);
pe.AddEquipment((ThingWithComps)ThingMaker.MakeThing(DefDatabase <ThingDef> .GetNamed("ra2_Gun_Tanya", true)));
//item.story = st;
return(item);
}
public static void Postfix(Pawn_WorkSettings __instance)
{
var fieldPriorities = Traverse.Create(__instance).Field("priorities");
var pawn = Traverse.Create(__instance).Field("pawn").GetValue();
var priorities = (DefMap <WorkTypeDef, int>)fieldPriorities.GetValue();
// Added: Make checks?
if (Scribe.mode == LoadSaveMode.PostLoadInit && priorities != null)
{
CheckForRemovedOrAdded(ref priorities, fieldPriorities);
CheckForDisabledTypes(__instance, (Pawn)pawn);
}
// Apply
fieldPriorities.SetValue(priorities);
}
public static bool Prefix(Pawn_WorkSettings __instance)
{
var pawn = pawnField.GetValue(__instance) as Pawn;
var allWorkgivers = DefDatabase <WorkGiverDef> .AllDefsListForReading
.Select(wgd => wgd.Worker)
.Where(wg => pawn.GetPriority(wg.def, -1) > 0);
var normalWorkgivers = new List <WorkGiver>();
var emergencyWorkgivers = new List <WorkGiver>();
// sort by player set workgiver priorities => worktype order => workgiver order
if (allWorkgivers.Any())
{
allWorkgivers = allWorkgivers
.OrderBy(wg => pawn.GetPriority(wg.def, -1))
.ThenByDescending(wg => wg.def.workType.naturalPriority)
.ThenByDescending(wg => wg.def.priorityInType).ToList();
// lowest priority non-emergency job
int maxEmergPrio = allWorkgivers
.Where(wg => !wg.def.emergency)
.Min(wg => pawn.GetPriority(wg.def, -1));
// create lists of workgivers
normalWorkgivers = allWorkgivers
.Where(wg => !wg.def.emergency || pawn.GetPriority(wg.def, -1) > maxEmergPrio)
.ToList();
emergencyWorkgivers = allWorkgivers
.Where(wg => wg.def.emergency && pawn.GetPriority(wg.def, -1) <= maxEmergPrio)
.ToList();
}
Logger.Debug($"Updating priorities for {pawn.LabelShort};\n\t" +
$"{string.Join("\n\t", emergencyWorkgivers.Select(wg => wg.def.label).ToArray())}" +
$"{string.Join("\n\t", normalWorkgivers.Select(wg => wg.def.label).ToArray())}");
// update cached lists of workgivers
workgiversNormalField.SetValue(__instance, normalWorkgivers);
workgiversEmergencyField.SetValue(__instance, emergencyWorkgivers);
workgiversDirtyField.SetValue(__instance, false);
// stop vanilla execution
return(false);
}
private void SpawnSetupWorkSettings()
{
if (workTypes == null)
{
//Log.Warning("Unexpected creation of converted pawn.");
workTypes = GetRandomWorkTypes(story);
}
WorkType = workTypes.Count > 0 ? workTypes[0].ToString() : String.Empty;
// Work
workSettings = new Pawn_WorkSettings(this);
workSettings.EnableAndInitialize();
var skillsDefs = new List <SkillDef>();
foreach (WorkTypeDef current in DefDatabase <WorkTypeDef> .AllDefs)
{
if (workTypes.Contains(current))
{
workSettings.SetPriority(current, 1);
skillsDefs.AddRange(current.relevantSkills);
}
else
{
workSettings.Disable(current);
}
}
skillsDefs.RemoveDuplicates();
foreach (var skillDef in skillsDefs)
{
var record = skills.GetSkill(skillDef);
var minSkillLevel = KindDef.minSkillPoints;
if (record == null || record.XpTotalEarned < minSkillLevel)
{
skills.Learn(skillDef, Rand.Range(minSkillLevel, KindDef.maxSkillPoints));
}
}
//foreach (WorkTypeDef current in DefDatabase<WorkTypeDef>.AllDefs)
//{
// if (workTypes.Contains(current))
// {
// }
//}
}
public static void ForcePriority(this Pawn_WorkSettings p, WorkTypeDef w, int priority)
{
p.ConfirmInitializedDebug();
if (
(priority < 0) ||
(priority > 4)
)
{
Log.Message("Trying to set work to invalid priority " + (object)priority);
}
var priorities = p.Priorities();
priorities[w] = priority;
if (priority == 0)
{
p.Pawn().mindState.Notify_WorkPriorityDisabled(w);
}
p.WorkGiversDirtySet(true);
}
public PawnSurface(Pawn pawn)
{
this.pawn = pawn;
Pawn_WorkSettings workSettings = this.pawn.workSettings;
for (int i = 0; i < Controller.GetPrimaries.PrimaryWorkList.Count; i++)
{
WorkTypeDef def = Controller.GetPrimaries.PrimaryWorkList[i].def;
bool incapablePawn = this.pawn.story.WorkTypeIsDisabled(def);
bool currentlyDisabled = workSettings.GetPriority(def) == 0; //Account for pre-existing priorities
DraggableWork newWork = new DraggableWork(def, incapablePawn, this, currentlyDisabled);
this.children.Add(newWork);
}
this.RefreshChildrenDictionary();
this.children = this.children.OrderByDescending(d => !d.CompletelyDisabled).ThenByDescending(d => workSettings.GetPriority(d.Def) != 0).ThenBy(d => workSettings.GetPriority(d.Def)).ToList(); //Account for pre-existing priorities
this.UpdatePawnPriorities();
}
static void Prefix(Pawn_WorkSettings __instance, WorkTypeDef w, int priority)
{
__instance.Pawn().SetPriority(w, priority, null);
}
static void SetPriority(Pawn_WorkSettings settings, WorkTypeDef def, int p) => settings.priorities[def] = p;
public static void Prefix(Pawn_WorkSettings __instance)
{
__instance.Pawn().DisableAll();
}
static bool Prefix(WorkTypeDef w, Pawn_WorkSettings __instance, ref int __result)
{
__result = __instance.Pawn().GetPriority(w, -1);
return(false);
}
static bool CacheWorkGiversInOrder(ref Pawn_WorkSettings __instance)
{
List <WorkTypeDef> wtsByPrio = new List <WorkTypeDef>();
List <WorkGiver> workGiversInOrderEmerg = ((List <WorkGiver>)__instance.GetField("workGiversInOrderEmerg"));
List <WorkGiver> workGiversInOrderNormal = ((List <WorkGiver>)__instance.GetField("workGiversInOrderNormal"));
List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading;
int num = 999;
for (int i = 0; i < allDefsListForReading.Count; i++)
{
WorkTypeDef workTypeDef = allDefsListForReading[i];
int priority = __instance.GetPriority(workTypeDef);
if (priority > 0)
{
if (priority < num)
{
if (workTypeDef.workGiversByPriority.Any((WorkGiverDef wg) => !wg.emergency))
{
num = priority;
}
}
wtsByPrio.Add(workTypeDef);
}
}
var tmp = __instance;
wtsByPrio.InsertionSort(delegate(WorkTypeDef a, WorkTypeDef b)
{
float value = (float)(a.naturalPriority + (4 - tmp.GetPriority(a)) * 100000);
return(((float)(b.naturalPriority + (4 - tmp.GetPriority(b)) * 100000)).CompareTo(value));
});
workGiversInOrderEmerg.Clear();
for (int j = 0; j < wtsByPrio.Count; j++)
{
WorkTypeDef workTypeDef2 = wtsByPrio[j];
for (int k = 0; k < workTypeDef2.workGiversByPriority.Count; k++)
{
WorkGiver worker = workTypeDef2.workGiversByPriority[k].Worker;
if (worker.def.emergency && __instance.GetPriority(worker.def.workType) <= num)
{
workGiversInOrderEmerg.Add(worker);
}
}
}
workGiversInOrderNormal.Clear();
for (int l = 0; l < wtsByPrio.Count; l++)
{
WorkTypeDef workTypeDef3 = wtsByPrio[l];
for (int m = 0; m < workTypeDef3.workGiversByPriority.Count; m++)
{
WorkGiver worker2 = workTypeDef3.workGiversByPriority[m].Worker;
if (!worker2.def.emergency || __instance.GetPriority(worker2.def.workType) > num)
{
workGiversInOrderNormal.Add(worker2);
}
}
}
__instance.SetField("workGiversDirty", false);
return(false);
}
