private static void DisableCommandIfNotActivated(Pawn_DraftController __instance, Command_Toggle toggleCommand)
{
if (toggleCommand.isActive() && !__instance.pawn.IsActivated())
{
__instance.Drafted = false;
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
//Kill all invalid spawns
if (this.station == null)
{
this.Kill(null);
return;
}
base.SpawnSetup(map, respawningAfterLoad);
skills = new Pawn_SkillTracker(this);
skillSettings = station.def.GetModExtension <ModExtension_Skills>();
station.GetDroneSkillsRecord = DroneSkills.UpdateSkills(skills, station.GetDroneSkillsRecord, skillSettings, true);
story = new Pawn_StoryTracker(this)
{
bodyType = BodyTypeDefOf.Thin,
crownType = CrownType.Average,
childhood = DroneBackstories.childhood,
adulthood = DroneBackstories.adulthood
};
drafter = new Pawn_DraftController(this);
relations = new Pawn_RelationsTracker(this);
Name = new NameSingle("PRFDroneName".Translate());
//Set the AreaRestriction. null means Unrestricted
playerSettings.AreaRestriction = this.station.droneAllowedArea;
}
public static void NotifyPawnUndrafted(Pawn_DraftController __instance, bool value)
{
if (!value)
{
PartyHuntHandler.OnPawnUndrafted(__instance.pawn);
}
}
private static void ResetAutoUndraftTimer(Pawn_DraftController draftController)
{
// resets the expiration timer on the pawn draft
var undrafter = (AutoUndrafter)AllowToolController.Instance.Reflection.DraftControllerAutoUndrafterField.GetValue(draftController);
undrafter.Notify_Drafted();
}
public static void set_DraftedPostFix(Pawn_DraftController __instance, bool value)
{
if (__instance == null)
{
return;
}
if (__instance.pawn is Pawn p && p.equipment is Pawn_EquipmentTracker eq &&
eq.Primary is ThingWithComps t &&
t.GetComp <OgsCompActivatableEffect.CompActivatableEffect>() is OgsCompActivatableEffect.CompActivatableEffect compActivatableEffect)
{
if (value == false)
{
if (compActivatableEffect.CurrentState == OgsCompActivatableEffect.CompActivatableEffect.State.Activated)
{
compActivatableEffect.TryDeactivate();
}
}
else
{
if (compActivatableEffect.CurrentState == OgsCompActivatableEffect.CompActivatableEffect.State.Deactivated)
{
compActivatableEffect.TryActivate();
}
}
}
}
private static void VerbGiverExtended(ref IEnumerable <Gizmo> __result, Pawn_DraftController __instance)
{
List <Gizmo> gizmos = new List <Gizmo>(__result); // normal gizmos
List <Gizmo> toggleGizmos = new List <Gizmo>();
List <Gizmo> rangedVerbGizmos = new List <Gizmo>();
// iterates over verbgivercomps
foreach (HediffComp_VerbGiverExtended verbGiverExtended in __instance.pawn.health.hediffSet.GetAllComps().Where(c => c is HediffComp_VerbGiverExtended))
{
// create a gizmo
Command_Toggle command_HediffToggle = new Command_Toggle
{
isActive = () => verbGiverExtended.canAutoAttack,
toggleAction = () => verbGiverExtended.canAutoAttack = !verbGiverExtended.canAutoAttack,
defaultLabel = verbGiverExtended.Props.toggleLabel,
defaultDesc = verbGiverExtended.Props.toggleDescription.CapitalizeFirst(),
icon = PCF_VanillaExtender.GetIcon(verbGiverExtended.Pawn.GetUniqueLoadID() + "_" + verbGiverExtended.parent.GetUniqueLoadID(), verbGiverExtended.Props.toggleIconPath),
iconAngle = verbGiverExtended.Props.toggleIconAngle,
iconOffset = verbGiverExtended.Props.toggleIconOffset
};
if (__instance.pawn.Faction != Faction.OfPlayer) // disable show on enemies
{
command_HediffToggle.Disable("CannotOrderNonControlled".Translate());
}
if (__instance.pawn.Downed) // disable on downed
{
command_HediffToggle.Disable("IsIncapped".Translate(__instance.pawn.LabelShort, __instance.pawn));
}
toggleGizmos.Add(command_HediffToggle); // add to list of toggles
// command to use verb
Command_HediffVerbRanged command_HediffVerbRanged = new Command_HediffVerbRanged
{
rangedComp = verbGiverExtended,
defaultLabel = verbGiverExtended.rangedVerbLabel,
defaultDesc = verbGiverExtended.rangedVerbDescription.CapitalizeFirst(),
icon = PCF_VanillaExtender.GetIcon(verbGiverExtended.Pawn.GetUniqueLoadID() + "_" + verbGiverExtended.rangedVerb.loadID, verbGiverExtended.rangedVerbIconPath),
iconAngle = verbGiverExtended.rangedVerbIconAngle,
iconOffset = verbGiverExtended.rangedVerbIconOffset
};
if (__instance.pawn.Faction != Faction.OfPlayer)
{
command_HediffVerbRanged.Disable("CannotOrderNonControlled".Translate());
}
else if (__instance.pawn.IsColonist)
{
if (__instance.pawn.story.DisabledWorkTagsBackstoryAndTraits.HasFlag(WorkTags.Violent))
{
command_HediffVerbRanged.Disable("IsIncapableOfViolence".Translate(__instance.pawn.LabelShort, __instance.pawn));
}
else if (!__instance.pawn.drafter.Drafted)
{
command_HediffVerbRanged.Disable("IsNotDrafted".Translate(__instance.pawn.LabelShort, __instance.pawn));
}
}
rangedVerbGizmos.Add(command_HediffVerbRanged);
}
__result = gizmos.Concat(toggleGizmos).Concat(rangedVerbGizmos);
}
private static Gizmo CreateGizmo_SearchAndDestroy_Ranged(Pawn_DraftController __instance)
{
string disabledReason = "";
bool disabled = false;
PawnDuty duty = __instance.pawn.mindState.duty;
ExtendedPawnData pawnData = Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(__instance.pawn);
if (__instance.pawn.Downed)
{
disabled = true;
disabledReason = "SD_Reason_Downed".Translate();
}
Gizmo gizmo = new Command_Toggle
{
defaultLabel = "SD_Gizmo_Ranged_Label".Translate(),
defaultDesc = "SD_Gizmo_Ranged_Description".Translate(),
hotKey = KeyBindingDefOf.Command_ItemForbid,
disabled = disabled,
order = 10.6f,
disabledReason = disabledReason,
icon = ContentFinder <Texture2D> .Get(("UI/" + "SearchAndDestroy_Gizmo_Ranged"), true),
isActive = () => pawnData.SD_enabled,
toggleAction = () =>
{
pawnData.SD_enabled = !pawnData.SD_enabled;
__instance.pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, true);
}
};
return(gizmo);
}
static IEnumerable <Gizmo> Postfix(IEnumerable <Gizmo> values, Pawn_DraftController __instance)
{
var pawn = __instance.pawn;
var newGizmos = values.ToList();
if (pawn?.GetBattleStation() != null)
{
(var draft, var draftIndex) = values.Select((gizmo, index) => (gizmo as Command_Toggle, index)).Where(item => item.Item1 != null && item.Item1.icon == TexCommand.Draft).FirstOrDefault();
var insertAtIndex = newGizmos.Count > 0 ? 1 : 0;
var draftAllowed = true;
if (draft != null)
{
draftAllowed = !draft.disabled;
insertAtIndex = draftIndex + 1;
}
if (draftAllowed)
{
newGizmos.Insert(insertAtIndex, Gizmo_BattleStationsButton.MakeGizmo(pawn));
}
}
foreach (var gizmo in newGizmos)
{
yield return(gizmo);
}
}
public static void Set_Drafted_PostFix(Pawn_DraftController __instance, bool value)
{
if (!value)
{
Pawn pawn = __instance.pawn;
if (pawn != null)
{
Pawn_EquipmentTracker pawn_EquipmentTracker = pawn.equipment;
if (pawn_EquipmentTracker != null)
{
//Log.Message("2");
//ThingWithComps thingWithComps = (ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker);
ThingWithComps thingWithComps = pawn_EquipmentTracker.Primary; //(ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker);
if (thingWithComps != null)
{
//Log.Message("3");
CompActivatableEffect compActivatableEffect = thingWithComps.GetComp <CompActivatableEffect>();
if (compActivatableEffect != null)
{
if (compActivatableEffect.CurrentState == CompActivatableEffect.State.Activated)
{
compActivatableEffect.Deactivate();
}
}
}
}
}
}
}
public static void Postfix(Pawn_DraftController __instance, bool value)
{
if (value)
{
return;
}
var extendedDataStore = Main.Instance.GetExtendedDataStorage();
if (extendedDataStore == null)
{
return;
}
var pawn = __instance.pawn;
if (!extendedDataStore.CanTrackPawn(pawn))
{
return;
}
Main.Instance.PawnStatusTracker.Remove(pawn);
if (!Main.Instance.ShouldEnableWhenUndrafted())
{
return;
}
var pawnData = extendedDataStore.GetExtendedDataFor(pawn);
pawnData.AvoidFriendlyFire = true;
}
public static void Postfix(ref IEnumerable <Gizmo> __result, ref Pawn_DraftController __instance)
{
if (__result == null)
{
return;
}
var list = __result.ToList();
var pawn = __instance.pawn;
if (pawn != null && pawn.equipment.Primary != null)
{
var ChkSprayer = pawn.equipment.Primary;
if (ChkSprayer.def.HasComp(typeof(CompUSToxUses)))
{
Gizmo item = new Gizmo_SprayerStatus
{
Sprayer = ChkSprayer
};
list.Add(item);
}
}
__result = list;
}
static void Postfix(Pawn_DraftController __instance)
{
Pawn pawn = __instance.pawn;
if (WorldComp.TryGetAssignedWeapons(pawn, out AssignedWeaponContainer weapons) &&
weapons.TryGetLastThingUsed(pawn, out ThingWithComps w))
{
HarmonyPatchUtil.EquipWeapon(w, pawn, weapons);
}
}
public static void Postfix(Pawn_DraftController controller, ref IEnumerable <Gizmo> __result)
{
// We add the command toggle corresponding to the token in the value
MRpawntoken token = MainController.GetPawnToken(controller.pawn);
AttackModeCommand optF = new AttackModeCommand(token);
List <Gizmo> list = __result.ToList <Gizmo>();
list.Add(optF);
__result = (IEnumerable <Gizmo>)list;
}
private static bool Prefix(Pawn_DraftController __instance, ref bool value)
{
if (__instance.pawn.CurJob.def == JobDefOf.LayDown && __instance.pawn.HasTrait(VTEDefOf.VTE_HeavySleeper))
{
value = false;
Messages.Message("VTE.CantBeWokenUpHeavySleeper".Translate(__instance.pawn.Named("PAWN")), __instance.pawn, MessageTypeDefOf.NeutralEvent, historical: false);
return(false);
}
return(true);
}
static void Postfix(Pawn_DraftController __instance)
{
var p = __instance.pawn;
if (p.IsColonist && !p.Dead && p.def.race.Humanlike)
{
PortraitsCache.SetDirty(p);
GlobalTextureAtlasManager.TryMarkPawnFrameSetDirty(p);
}
}
public static void Postfix(Pawn_DraftController __instance)
{
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (store != null && !__instance.Drafted)
{
ExtendedPawnData pawnData = store.GetExtendedDataFor(__instance.pawn);
pawnData.SD_enabled = false;
}
}
/// <summary>
/// Draft gizmos for VehiclePawn
/// </summary>
/// <param name="drafter"></param>
public static IEnumerable <Gizmo> DraftGizmos(Pawn_DraftController drafter)
{
Command_Toggle command_Toggle = new Command_Toggle();
command_Toggle.hotKey = KeyBindingDefOf.Command_ColonistDraft;
command_Toggle.isActive = (() => drafter.Drafted);
command_Toggle.toggleAction = delegate()
{
drafter.Drafted = !drafter.Drafted;
PlayerKnowledgeDatabase.KnowledgeDemonstrated(ConceptDefOf.Drafting, KnowledgeAmount.SpecificInteraction);
if (drafter.Drafted)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.QueueOrders, OpportunityType.GoodToKnow);
}
};
command_Toggle.defaultDesc = "CommandToggleDraftDesc".Translate();
command_Toggle.icon = TexCommand.Draft;
command_Toggle.turnOnSound = SoundDefOf.DraftOn;
command_Toggle.turnOffSound = SoundDefOf.DraftOff;
if (!drafter.Drafted)
{
command_Toggle.defaultLabel = "CommandDraftLabel".Translate();
}
if (drafter.pawn.Downed)
{
command_Toggle.Disable("IsIncapped".Translate(drafter.pawn.LabelShort, drafter.pawn));
}
if (!drafter.Drafted)
{
command_Toggle.tutorTag = "Draft";
}
else
{
command_Toggle.tutorTag = "Undraft";
}
yield return(command_Toggle);
if (drafter.Drafted && drafter.pawn.equipment.Primary != null && drafter.pawn.equipment.Primary.def.IsRangedWeapon)
{
yield return(new Command_Toggle
{
hotKey = KeyBindingDefOf.Misc6,
isActive = (() => drafter.FireAtWill),
toggleAction = delegate()
{
drafter.FireAtWill = !drafter.FireAtWill;
},
icon = TexCommand.FireAtWill,
defaultLabel = "CommandFireAtWillLabel".Translate(),
defaultDesc = "CommandFireAtWillDesc".Translate(),
tutorTag = "FireAtWillToggle"
});
}
yield break;
}
public static void DraftedSetter(Pawn_DraftController __instance)
{
//Log.Message("undraft intercept: " + __instance.Drafted);
if (!__instance.Drafted)
{
Pawn pawn = __instance.pawn;
if (pawn != null && !pawn.Dead && pawn.IsColonist)
{
GoldfishModule.GetGoldfishForPawn(pawn).InformOfUndraft();
}
}
}
private static void DisableCommandIfMechanoidPowerLow(Pawn_DraftController __instance, Command_Toggle toggleCommand)
{
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (store != null)
{
if (__instance.pawn.ShouldRecharge())
{
toggleCommand.Disable("WTH_Reason_PowerLow".Translate());
}
}
}
static void Postfix(Pawn_DraftController __instance)
{
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (store != null)
{
ExtendedPawnData pawnData = store.GetExtendedDataFor(__instance.pawn);
if (__instance.Drafted)
{
pawnData.isActive = true;
}
}
}
static void Postfix(Pawn_DraftController __instance)
{
StoredApparelSet set;
if (StoredApparelContainer.TryGetBattleApparelSet(__instance.pawn, out set))
{
if ((__instance.Drafted && !set.IsBeingWorn) ||
(!__instance.Drafted && set.IsBeingWorn))
{
set.SwapApparel(__instance.pawn);
}
}
}
private static void DisableCommandIfMechanoidPowerLow(Pawn_DraftController __instance, Command_Toggle toggleCommand)
{
Need_Power powerNeed = __instance.pawn.needs.TryGetNeed(WTH_DefOf.WTH_Mechanoid_Power) as Need_Power;
ExtendedDataStorage store = Base.Instance.GetExtendedDataStorage();
if (powerNeed != null && store != null)
{
ExtendedPawnData pawnData = store.GetExtendedDataFor(__instance.pawn);
if (pawnData.shouldAutoRecharge && powerNeed.CurCategory >= PowerCategory.LowPower)
{
toggleCommand.Disable("WTH_Reason_PowerLow".Translate());
}
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
// Workaround for issue where getting gizmos for ghosts would result in a NullReferenceException, due to:
// a) force ghosts having only ToolUser intelligence
// b) pawn.drafter only being initialized for Humanlike intelligence
// c) force ghost holding a weapon and thus stored in Pawn_EquipmentTracker as a CompEquippable'd Thing
// d) Pawn.GetGizmos => Pawn_EquipmentTracker.GetGizmos => CompEquippable.GetVerbsCommands
// => VerbTracker.GetVerbsCommands => VerbTracker.CreateVerbTargetCommand
// usually requiring pawn.drafter to not be null
if (drafter == null)
{
drafter = new Pawn_DraftController(this);
}
}
private static void PawnLevelAccess(Pawn_DraftController __instance, ref IEnumerable <Gizmo> __result)
{
if (!__instance.Drafted)
{
List <Gizmo> gizmos = __result.ToList();
Command_KeycardPawn keyGizmo = new Command_KeycardPawn();
keyGizmo.pawn = __instance.pawn;
keyGizmo.icon = ContentFinder <Texture2D> .Get("Keycards/Gizmo/KeycardIcon/KeyCardIcon", true);
keyGizmo.defaultLabel = "SCP_SetLevelAccess".Translate();
keyGizmo.defaultDesc = "SCP_SetLevelAccessDesc".Translate();
gizmos.Insert(0, keyGizmo);
__result = gizmos;
}
}
public static bool Prefix(Pawn_DraftController __instance, bool ___draftedInt)
{
//Logger.MessageFormat(__instance, "Drafted Prefix");
if (__instance.pawn != null && ___draftedInt)
{
CompMeeseeksMemory compMeeseeksMemory = __instance.pawn.GetComp <CompMeeseeksMemory>();
if (compMeeseeksMemory != null)
{
return(false);
}
}
return(true);
}
private static void Pawn_DraftController_Drafted_Postfix(Pawn_DraftController __instance)
{
Pawn pawn = __instance.pawn;
if (pawn.Drafted)
{
DoNotDisturbManager manager = pawn.Map.GetComponent <DoNotDisturbManager>();
// Unforbid doors if a pawn has been drafted, for QoL purposes (otherwise it will take a second)
manager?.SetRoomDoors(pawn.GetRoom(), false);
#if DEBUG
Log.Message($"Do Not Disturb :: Unlocked doors for drafted pawn {pawn.Name} with manager {manager.ToString()}");
#endif
}
}
static void Postfix(Pawn_DraftController __instance)
{
Pawn pawn = __instance.pawn;
PawnOutfitTracker outfits;
if (WorldComp.PawnOutfits.TryGetValue(pawn, out outfits))
{
if (pawn.Drafted)
{
outfits.ChangeToBattleOutfit();
}
else
{
outfits.ChangeToCivilianOutfit();
}
}
}
public static void Postfix(ref IEnumerable <Gizmo> __result, ref Pawn_DraftController __instance)
{
if (!Main.Instance.IsModEnabled())
{
return;
}
if (Find.CurrentMap == null || Find.World == null || Find.World.renderer == null ||
Find.World.renderer.wantedMode == WorldRenderMode.Planet)
{
return;
}
if (__result == null || !__result.Any())
{
return;
}
var extendedDataStore = Main.Instance.GetExtendedDataStorage();
var pawn = __instance.pawn;
if (!extendedDataStore.CanTrackPawn(pawn))
{
return;
}
if (!FireConeOverlay.HasValidWeapon(pawn))
{
return;
}
var pawnData = extendedDataStore.GetExtendedDataFor(pawn);
var gizmoList = __result.ToList();
var ourGizmo = new Command_Toggle
{
defaultLabel = "Avoid Friendly Fire",
icon = Resources.FriendlyFireIcon,
isActive = () => pawnData.AvoidFriendlyFire,
toggleAction = () => pawnData.AvoidFriendlyFire = !pawnData.AvoidFriendlyFire
};
gizmoList.Add(ourGizmo);
__result = gizmoList;
}
public static void Postfix(ref IEnumerable <Gizmo> __result, Pawn_DraftController __instance)
{
List <Gizmo> gizmoList = __result.ToList();
bool isPlayerPawn = __instance.pawn.Faction != null && __instance.pawn.Faction.IsPlayer;
if (isPlayerPawn && __instance.pawn.equipment != null && __instance.pawn.Drafted && (__instance.pawn.story == null || !__instance.pawn.WorkTagIsDisabled(WorkTags.Violent)))
{
if (__instance.pawn.equipment.Primary == null || __instance.pawn.equipment.Primary.def.IsMeleeWeapon)
{
gizmoList.Add(CreateGizmo_SearchAndDestroy_Melee(__instance));
}
else
{
gizmoList.Add(CreateGizmo_SearchAndDestroy_Ranged(__instance));
}
}
__result = gizmoList;
}
public static void HediffGizmos(ref IEnumerable <Gizmo> __result, Pawn_DraftController __instance)
{
List <Gizmo> gizmos = new List <Gizmo>(__result);
List <Hediff> hediffs = __instance.pawn.health.hediffSet.hediffs;
for (int i = 0; i < hediffs.Count; i++)
{
HediffComp_HediffGizmo hediffGizmo = hediffs[i].TryGetComp <HediffComp_HediffGizmo>();
if (hediffGizmo != null)
{
foreach (Gizmo h in hediffGizmo.CompGetGizmos())
{
gizmos.Add(h);
}
}
}
__result = gizmos;
}
