Requirement Dictionaries

Whenever the game needs to evaluate if a condition within the data is true, the same format is always used. A requirement dictionary.

The dictionary is a pairing of requirement keywords, indicating what is to be evaluated, and the expected values of those evaluations. If the state of every requirement keyword in the dictionary evaluates to match the given expected value, then the entire dictionary resolves to true, and is considered valid.

In addition, wherever a requirement dictionary can be used, an Array of multiple requirement dictionaries can also be used. If ANY requirement dictionary inside of an Array of dictionaries resolves to true, then the entire

Put another way; All requirements in a requirement dictionary are logically ANDed together. Sets of requirement dictionaries in an Array are logically ORed together.

Generally, the context of where the requirements are going to be evaluated what information is available to check against.

For example, evaluating a dictionary of {"HasStatus": "SE_Dazed"} within the context of an ally's skill that you do or don't want to have activate makes sense. Evaluating that same dictionary within the context of if a monster can spawn during floor generation doesn't make sense and would fail, as the game wouldn't have a character to look at when evaluating the "HasStatus" requirement.

In general, any requirement being evaluated for the purpose of if a check should be triggered will have the information about the character related to that check, as well as any information set by the parent.

A list of all requirement keywords in the game, as well as the data type of the expected value that should be given to it:

"fail": bool
	Causes the requirement dictionary to always evaluate to false, failing. This is used internally to hide content. It's not particularly useful.
	Example: {"fail": true} ALWAYS evaluates to false regardless of anything else in the dictionary.

NOTE: In the current game version, "not", "self", and "target" only accept single requirement dictionaries and will not properly evaluate an array of multiple requirement dictionaries. This will be fixed in the future.

"not": Requirement Dictionary
	Evaluates the given requirement dictionary(s). If this evaluation returns true, then the result of the "not" keyword becomes false. This is a logical negation.
	Example: {"not": {"HasSkill": "SK_OpeningStrike"}} evaluates to true if the character does NOT have the Opening Strike skill.

"self": Requirement Dictionary
	Evaluates the given requirement dictionary(s), substituting in the owner of the effect that has this requirement as the character being checked, rather than the original character being checked.
	Example:

"target": Requirement Dictionary
	Evaluates the given requirement dictionary(s), substituting in the character in the "target" field of the parent check as the character being checked, rather than the original character being checked.

"randomcheck": float
	Rolls a random number between 0 and 1. Returns true if the number rolled is <= the float value given.
	Example: {"randomcheck": 0.75} evaluates to true 75% of the time.

"allreqsrandomcheck": float
	Functions like "randomcheck", however the SAME random number is used until a new player generated event happens. This allows multiple requirements to be evaluated based on a single random number generation.

"tutorialactive": bool
	Returns true if the bool value given matches whether or not the player went through the tutorial at the beginning of this run.

"playersex": String
	Returns true if the String value given matches the player's current sex. Player sex is stored as either "M" or "F".

"playerscryoncooldown": bool
	Returns true if the bool value matches whether or not the player's scry spell is on cooldown within the dungeon.

"playerknowsspell": String
	Returns true if the given String is inside the list of the player's known spell IDs.
	Example: {"playerknowsspell": "SP_Quality"} evaluates to true if the player knows the Quality spell.

"playerhasspellactive": String
	Returns true if the given String is inside the list of the player's active spell IDs.

"playerprogresscurses": bool
	Returns true if the bool value given matches whether or not the player has reached the point in the game where curses are introduced.

"playerprogressspells": bool
	Returns true if the bool value given matches whether or not the player has reached the point in the game where they gain access to the scry spell (or have retained spellcasting from new game+).

"playerprogressdesiremanip": bool
	Returns true if the bool value given matches whether or not the player has reached the point in the game where they gain access to desire manipulation (or have retained desire manipulation from new game+).

"playerprogresscorruptionwaves": bool
	Returns true if the bool value given matches whether or not the player has reached the point in the game where they gain access to desire manipulation (or have retained desire manipulation from new game+).

"newgameplusbonusactive": String
	Returns true if the given string is in the list of active new game+ bonus IDs for this run.

"currentfloor": String
	Returns true if the given string matches the ID of the current dungeon floor.

"spell": String
	Returns true if the given string matches the ID of a spell currently being cast.

"checkally": Special dictionary. Format of: {"ally_ID": string, "requirements": {requirement dictionary(s)}}
	Evaluates the requirement dictionary(s) given using the specified ally as the character being checked.
	Example: {"ally_ID": "A_Lucette", "requirements": {"HasCurse": "CU_Masochism"}} evaluates to true if specifically Lucette has the masochism curse.

"checkanyally": Requirement Dictionary
	Evaluates the requirement dictionary(s) given using each ally in turn. If it evaluates to true for ANY of them, the entire requirement evaluates to true. This is logically equivalent to doing checkally OR checkally OR checkally for the same set of requirements each time.

"character": String
	Expects a set of specific values:
		"self": Returns true if the character who is being checked is the same character who is generating the parent effect causing this requirement dictionary to be evaluated. Status effect, skill, and curse checks all insert an implicit "character": "self" requirement unless otherwise specified.
		Example: The Opening Strike skill has an implicit "character": "self" requirement. This is so it only triggers its checks when the character who actually HAS the skill attacks, rather than when ANY character attacks.

		"notself": Does the opposite of "self". This is a shortcut to do the logical same thing as "not": {"character": "self"}.

		"source_character": Returns true if the character that owns the check that triggered this one is the same as the character being checked.
		This is hard for even me to explain honestly.

"stat": String
	Returns true if the check that triggered this one was referring to a specific stat.
	Example: Adding a requirement of {"stat": "INJURY"} to a check that triggers off of "ALLY_TAKE_DAMAGE" will only evaluate to true when an ally is about to take Injury damage, returning false for all other damage types.

"comparison": Dictionary or Array of Dictionaries
	A dictionary to be used in a comparison has 3 expected fields:
		"amount1": Amount field
		"comparison": String, one of "=", "!=", ">", "<", "=>", "<="
		"amount2": Amount field
	Each dictionary supplied is evaluated by getting the value of each amount field and comparing them using the given comparison operator. If all comparison dictionaries are true, the comparison requirement is true. (They are logically ANDed together)
	Example: {"comparison": {"amount1": "%ally_stat%Physique", "comparison": ">", "amount2": "%ally_stat%Willpower"}} will evaluate to true if the ally's Physique stat is greater than their Willpower stat.

"anycomparison": Array of Dictionaries
	Works like "comparison", but if any one dictionary evaluates to true, the anycomparison requirement is true (They are logically ORed together).
	Example: {"anycomparison": [
	{"amount1": "%ally_stat%Physique", "comparison": ">", "amount2": "%ally_stat%Willpower"},
	{"amount1": "%ally_stat%Physique", "comparison": ">", "amount2": "%ally_stat%Health"}
	]} will evaluate to true if the ally's Physique stat is greater than their Willpower stat OR their Health stat.

"status": String or Array of Strings
	Returns true if the check that triggered this one was referring to any number of specific status effects.
	Example: Adding a requirement of {"status": ["SE_Weakened", "SE_Fatigued"]} to a check that triggers off of "ALLY_GAIN_STATUS" will only evaluate to true when an ally is about to gain the Weakened or Fatigued statuses, returning false for all other status effect gains.

"hasstatus": String or Array of Strings
	Returns true if the ally currently has a status effect with the given effect_ID. If multiple IDs are given as an array, this only returns true if the ally has ALL of them (they are logically ANDed together).

"hasanystatus": Array of Strings
	Returns true if the ally currently has a status effect with ANY of the given effect_IDs (they are logically ORed together).
	"hasanystatus": ["status1", "status2"] is a shortcut for the logically equivalent set of requirements [{"hasstatus": "status1"}, {"hasstatus": "status2"}]. This is similarly the case for any other "has" and "hasany" requirements.

"hasvisiblestatus": String or Array of Strings
	Returns true if the ally currently has a VISIBLE status effect with the given effect_ID. If multiple IDs are given as an array, this only returns true if the ally visibly has ALL of them (they are logically ANDed together).

"hasstatuswithtag": String or Array of Strings
	Returns true if any of the status effects the ally currently has have the given Tag. If multiple tags are given as an array, this only returns true if ALL tags are present on at least one status effect. All the tags do NOT need to be present on the SAME status effect.

TODO: Should implement a "hasstatuswithanytag" and probably a "hasstatuswithalltags". Same with curses.

"statushastag": String or Array of Strings
	Returns true if the status that the check that triggered this one was referring to has ALL the given Tag(s). If multiple Tags are given as an array, this only returns true if the status has ALL of them (they are logically ANDed together).
	Example: {"trigger": "ALLY_GAIN_STATUS", "requirements": {"statushastag": "physique_penalty"}} would be true if the status about to be gained was Weakened or Gooey, but would return false if the status about to be gained was Shaken or Dazed.

"statushasanytag": Array of Strings
	Returns true if the status that the check that triggered this one was referring to has ANY of the given Tag(s). If multiple Tags are given as an array, this returns true if the status has ANY of them (they are logically ORed together).

TODO: "statuswithtagflatcompare" needs to be moved into "comparison", along with any other tag comparisons (although no others are currently used/in existence)

"hasskill": String or Array of Strings
	Returns true if the ally currently knows a skill with the given skill_ID. If multiple IDs are given as an array, this only returns true if the ally knows ALL of them (they are logically ANDed together).

"hasanyskill": Array of Strings
	Returns true if the ally currently knows a skill with ANY of the given skill_IDs (they are logically ORed together).

"hasskillwithtag": String or Array of Strings
	Returns true if any of the skills the ally currently knows have the given Tag. If multiple tags are given as an array, this only returns true if ALL tags are present on at least one skill. All the tags do NOT need to be present on the SAME skill.

"hasskillwithanytag": Array of Strings
	Returns true if any of the skills the ally currently knows have ANY of the given Tags (they are logically ORed together).

"hasskillwithalltags": Array of Strings
	Returns true if any singular skill the ally currently knows has ALL of the given Tags (they are logically ANDed together).

"hasskillatrank": Dictionary with a format of {"skill": skill_ID String, "rank": int, OPTIONALLY "allow_greater": bool}
	Returns true if the ally knows a skill with the given skill_ID and their rank in that skill is equal to the given rank value. If "allow_greater" is present and equal to true, the requirement is still valid if the actual rank is greater than or equal to the given rank value, otherwise they must be exactly equal.
	Example:
		"hasskillatrank": {"skill": "SK_OpeningStrike", "rank": 2} is only valid if the ally has the Opening Strike skill at rank 2.
		"hasskillatrank": {"skill": "SK_OpeningStrike", "rank": 2, "allow_greater": true} is valid if the ally has the Opening Strike skill at 2 or higher.

"hascurse": String or Array of Strings
	Returns true if the any of the curses the ally is currently under has the given curse_ID. If multiple IDs are given as an array, this only returns true if the ally is under ALL of them (they are logically ANDed together).

"hasanycurse": Array of Strings
	Returns true if the ally is currently under a curse with ANY of the given curse_IDs (they are logically ORed together).

"hasrevealedcurse": String or Array of Strings
	Returns true if the any of the curses the ally is currently under has the given curse_ID and are have had their effects revealed. If multiple IDs are given as an array, this only returns true if the ally is under ALL of them and ALL of them have been revealed (they are logically ANDed together).

"hascurseatrank": Dictionary with a format of {"curse": curse_ID String, "rank": int, OPTIONALLY "allow_greater": bool}
	Returns true if the ally is under a curse with the given curse_ID and their rank in that curse is equal to the given rank value. If "allow_greater" is present and equal to true, the requirement is still valid if the actual rank is greater than or equal to the given rank value, otherwise they must be exactly equal.

"hasembracedcurse": String or Array of Strings
	Returns true if the ally is currently under and has embraced a curse with the given curse_ID. If multiple IDs are given as an array, this only returns true if the ally has embraced ALL of them (they are logically ANDed together).

"hasembracedanycurse": Array of Strings
	Returns true if the ally is currently under and has embraced a curse with ANY of the given curse_IDs (they are logically ORed together).

"trackerbeingchanged": String
	For use with the CHANGE_TRACKER_VALUE check specifically. Returns true if the name of the tracker changed by the check matches the given String.

"trackeraddtoamountpositive": bool
	For use with the CHANGE_TRACKER_VALUE check specifically. If the given boolean is true, this requirement returns true only if the amount field in the CHANGE_TRACKER_VALUE check information resolves to a number greater than 0. If the given boolean is false, this requirement returns true only if the amount field in the CHANGE_TRACKER_VALUE check information resolves to a number less than 0.
	This will always return false if the amount field in the CHANGE_TRACKER_VALUE check information resolves to 0.

"allyinteraction": String or Array of Strings
	For use with the ALLY_TO_ALLY_INTERACTION and ALLY_TO_ALLY_INTERACTED checks specifically. Returns true if the interaction_ID of the parent check information matches the given interaction_ID. If multiple IDs are given as an array, this returns true if it matches ANY of them (they are logically ORed together).

"source": String
	Returns true if the parent check was originally triggered by something (status effect, skill, curse, etc) with the given ID string.
	Example: {"trigger": "ALLY_TAKE_DAMAGE", "requirements": {"source": "CU_Sadism"}} would be true only when the ally is about to take damage from the Sadism curse.

"parentsource": String
	Works like "source", but looks one step up at the parent check's parent check.

"sourcecharacter": String ("self" or "notself")
	Returns true if the "source_character" field on the parent check's information matches the character being checked for this requirement.
	TODO: How much is this used, and how is it different from "character": "self" and "character": "source_character"? Needs investigation.

"sourcehastag": String or Array of Strings
	Returns true if the parent check was originally triggered by something (status effect, skill, curse, etc) with the given Tag. If multiple tags are given as an Array, returns true only if the source has ALL the given tags (they are logically ANDed together).
	Example: {"trigger": "ALLY_DAMAGE_WAS_TAKEN", "requirements": {"sourcehastag": "event"}} would be true only when the ally has taken damage from an event, rather than through other sources like curses or movement.

TODO: Want to eventually refactor how room conditions can be defined/combined
"room": String or Array of Strings
	Expects one or more of a specific set of values. If multiple strings are given as an Array, returns true only if ALL conditions are true (they are logically ANDed together).
		"same": Returns true if the room containing the thing being evaluated is the same room that the ally being evaluated is currently inside.
		"ally_present": Returns true if there is an ally in the room OTHER THAN the ally being evaluated.
		"multiple_allies_present": Returns true if there is more than one ally in the room OTHER THAN the ally being evaluated
		"monstersame": Returns true if the room containing the thing being evaluated is the same room that the monster being evaluated is currently inside.
		"trapsame": Returns true if the room containing the thing being evaluated is the same room that the trap being evaluated is currently inside.

"roomtype": String or Array of Strings
	Expects one or more of the following: "EMPTY_ROOM", "SAFE_ROOM", "TRAP_ROOM", "MONSTER_ROOM", "END_ROOM", "WITCH_DEN", "SHRINE", "CHEST_ROOM".
	Returns true if the type of the room containing the thing being evaluated matches the given room type. If multiple types are given as an Array, returns true if the room is ANY of the given types (they are logically ORed together).

"roomexplored": bool
	If the given boolean value is true, returns true if the room containing the thing being evaluated has been explored by an ally. If the given value is false, does the opposite.

"roomdark": bool
	If the given boolean value is true, returns true if the room containing the thing being evaluated is obscured by darkness. If the given value is false, does the opposite.

"roomchesttrapped": bool
	If the given boolean value is true, returns true if the room containing the thing being evaluated is a chest room that contains a trap. If the given value is false, does the opposite.

"roomhasrewardchest": bool
	If the given boolean value is true, returns true if the room containing the thing being evaluated is a monster room where the monster is guarding a chest. If the given value is false, does the opposite.

"alliesinadjacentroom": bool
	If the given boolean value is true, returns true if any of the rooms adjacent to the room containing the thing being evaluated has at least one ally inside. If the given value is false, does the opposite.

"monster": String
	Expects one of the following:
		"self": returns true if the monster who is being checked is the same monster who is generating the parent effect causing this requirement dictionary to be evaluated. Monster status effects insert an implicit "monster": "self" requirement unless otherwise specified.
		"notself": Does the opposite of "self". This is a shortcut to do the logical same thing as "not": {"monster": "self"}.

"sourcemonster": Strings
	Works like "monster", but looks one step up at the parent check's parent check.

"monsterhastag": String or Array of Strings
	Returns true if the monster being evaluated has ALL the given Tag(s). If multiple Tags are given as an array, this only returns true if the monster has ALL of them (they are logically ANDed together).

"monsterhasanytag": Array of Strings
	Returns true if the monster being evaluated has ANY of the given Tags (they are logically ORed together).

"monsterhasstatus": String or Array of Strings
	Returns true if the monster being evaluated currently has a status effect with the given effect_IDs. If multiple effect_IDs are given as an array, this only returns true if the monster has ALL of them (they are logically ANDed together).

"monsterhasanystatus": Array of Strings
	Returns true if the monster being evaluated currently has a status effect with ANY of the given effect_IDs (they are logically ORed together).

TODO: This should be deprecated as it is already covered by monsterhasanystatus. I don't actually think I use it, but I should double check.
"monsterhasanymodifier"

"monstercounterattack": bool
	For use with the ALLY_COMBAT_ATTACKED check specifically. If the given boolean is true, returns true if the monster attacking is doing so as a counter to being attacked that turn. If the given boolean is false, returns true only if the monster attacking is doing so without being attacked first that turn.

"monsteropportunityattack": bool
	For use with the ALLY_COMBAT_ATTACKED check specifically. If the given boolean is true, returns true if the monster attacking is going to receive an attack bonus due to attacking an ally that is leaving the room. If the given boolean is false, does the opposite.

"trap": String
	Works like "monster" but when evaluating a trap rather than a monster.

"traphastag": String or Array of Strings
	Works like "monsterhastag" but when evaluating a trap rather than a monster.

"traphasanytag": Array of Strings
	Works like "monsterhasanytag" but when evaluating a trap rather than a monster.

"traphasstatus": String or Array of Strings
	Works like "monsterhasstatus" but when evaluating a trap rather than a monster.

TODO: Is this still used? SHOULD it be used? I think monsterhasstatus and traphasstatus would be preferred.
"targethasstatus"

TODO: event_monsterid and event_trapid are very old (and event_chesttrapid is based off of them). Can they be deprecated by "monster" and "trap"? Need to investigate.
"event_monsterid": String
	Returns true if the monster causing a dungeon event to occur matches the given monster_ID.

"event_trapid": String
	Returns true if the trap causing a dungeon event to occur matches the given trap_ID.

"event_chesttrapid": String
	Returns true if the chest trap causing a dungeon event to occur matches the given trap_ID.

"event_trappreviouslyencountered": boolean
	If the given boolean is true, returns true if the trap creating an event has already been encountered by an ally. If the given boolean is false, returns true if the trap's room has not been entered by an ally previously.

"eventhappened": String or Array of Strings
	Returns true if an event with the given event_ID has happened as a dungeon or camp event at some point previously. This counts the current run as well as any previous runs that had their events saved due to carrying over Knowledge Points into New Game+. If multiple event_IDs are given as an array, ALL of them must have happened previously (they are logically ANDed).

"eventhappenedthisrun": String or Array of Strings
	Returns true if an event with the given event_ID has happened as a dungeon or camp event at some point previously. This counts the current run only. If multiple event_IDs are given as an array, ALL of them must have happened previously (they are logically ANDed).

"eventseen": String or Array of Strings
	Returns true if an event with the given event_ID has been viewed as a dungeon or camp event at some point previously. This counts the current run as well as any previous runs that had their events saved due to carrying over Knowledge Points into New Game+. Most importantly, this does NOT include events that have ONLY happened in darkened rooms. If multiple event_IDs are given as an array, ALL of them must have been seen previously (they are logically ANDed).

"eventseenthisrun": String or Array of Strings
	Returns true if an event with the given event_ID has been viewed as a dungeon or camp event at some point previously. This counts the current run only. Most importantly, this does NOT include events that have ONLY happened in darkened rooms. If multiple event_IDs are given as an array, ALL of them must have been seen previously (they are logically ANDed).

"ploteventhappened": String or Array of Strings
	Returns true if an event with the given event_ID has happened as a plot event at some point previously. This counts the current run as well as any previous runs that had their events saved due to carrying over Knowledge Points into New Game+. If multiple event_IDs are given as an array, ALL of them must have happened previously (they are logically ANDed).

"ploteventhappenedthisrun": String or Array of Strings
	Returns true if an event with the given event_ID has happened as a plot event at some point previously. This counts the current run only. If multiple event_IDs are given as an array, ALL of them must have happened previously (they are logically ANDed).

"eventhappenedcharacter": Dictionary or Array of Dictionaries with the structure: {"event_ID": String event_ID, "ally_ID": String ally_ID}
	Returns true if an event with the given event_ID has happened to an ally with the given ally_ID as a dungeon or camp event at some point previously. This counts the current run as well as any previous runs that had their events saved due to carrying over Knowledge Points into New Game+. If multiple dictionaries are given, ALL of them must return true (they are logically ANDed).

"eventhappenedthisruncharacter": Dictionary or Array of Dictionaries with the structure: {"event_ID": String event_ID, "ally_ID": String ally_ID}
	Returns true if an event with the given event_ID has happened to an ally with the given ally_ID as a dungeon or camp event at some point previously. This counts the current run only. If multiple dictionaries are given, ALL of them must return true (they are logically ANDed).

"dialoguechoicevalue":
	TODO: This is coded really weird. Need to refactor probably.

"activity_participants":
	TODO: Also coded really weird

"camptimeofday": String or Array of Strings, one of: "LATE_NIGHT", "BEFORE_DAWN", "MORNING", "DAYTIME", "DAYTIME2", "DAYTIME3", "EVENING", "NIGHT"
	Returns true if the current time of day in camp matches the given time. If multiple times are given, returns true if the current time matches ANY of them (they are logically ORed together).

"location": String or Array of Strings
	Returns true if the location where things are being evaluated matches the given location_ID. If multiple IDs are given as an array, returns true if the location matches ANY of them (they are logically ORed together).

"allypresentinsamelocation": bool
	If the given boolean is true, returns true if there is an ally present in the same location as the one being evaluated. If the given boolean is false, returns true if the ally is alone.

"doingcampactivity": String or Array of Strings, one of: RELAX, READ, STUDY, PRAY, EXERCISE, TRAIN, MAINTAIN, CLEAN, COOK, ART, TALK, WALK, PLAY, BATHE, HUNT, FISH, RECOVER, MASTURBATE, SEX, SLEEP1, SLEEP2, INQUISITOR
	Returns true if the ally being evaluated is doing the given activity in camp. If multiple activities are given as an Array, returns true if the ally is doing ANY of them (they are logically ORed together).

"doingspecificactivitydescription": String or Array of Strings
	Returns true if the specific activity the ally being evaluated is doing matches the given activity_ID. If multiple IDs are given as an Array, returns true if the ally is doing ANY of them (they are logically ORed together).

"activityinlocation": Dictionary or Array of Dictionaries with the format: {"activity": String activity_ID, "location": String location_ID}
	Returns true if the given activity_ID is being performed in the given location_ID. If multiple dictionaries are given as an array, returns true if ANY pair of activity and location match (they are logically ORed together).

"playerjoinedactivity": bool
	If the given boolean is true, returns true if the player chose the option to spend time with an ally in camp while this requirement is being evaluated. If the given boolean is false, does the opposite.

"playerisasleep": bool
	If the given boolean is true, returns true if the inquisitor is asleep while this requirement is being evaluated. If the given boolean is false, does the opposite.

"tenttopic": String or Array of Strings, one or many of "Ideals_Up", "Ideals_Down", "Growth_Up, "Growth_Down", "Knowledge_Up", "Knowledge_Down", "Autonomy_Up", "Autonomy_Down", "Pleasure_Up", "Pleasure_Down", "Material_Up", "Material_Down", "Triumph_Up", "Triumph_Down", "Success_Up", "Success_Down", "Community_Up", "Community_Down", "Relaxation_Up", "Relaxation_Down"
	Returns true if the topic being discussed with an ally inside the inquisitor's tent matches the given topic string. If multiple topics are given as an Array, returns true if the topic matches ANY of them (they are logically ORed together).

"tentactiontype": String or Array of Strings
	Returns true if a specific action is being performed by the inquisitor while with an ally inside their tent. If multiple actions are given as an Array, returns true if the action matches ANY of them (they are logically ORed together).

"entranced": bool
	If the given boolean is true, returns true if the ally inside the Inquisitor's tent is currently in a trance. If the given boolean is false, does the opposite.

"hastentmodifier": String or Array of Strings
	Returns true if the ally inside the Inquisitor's tent has the given tent_modifier_ID. If multiple ids are given as an Array, returns true if the ally has ALL of them (they are logically ANDed together).

"hasanytentmodifier": Array of Strings
	Returns true if the ally inside the Inquisitor's tent has ANY of the given tent_modifier_IDs (they are logically ORed together).