-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"BanterFunctionObjectBase",
	},
	group = "Conditions",
	id = "BanterHasPlayed",
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if a banter has played, ever",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Banter",
	}),
	PlaceObj('PropertyDefPresetIdList', {
		'id', "Banters",
		'name', "Banters",
		'help', "List of banters to play.",
		'preset_class', "BanterDef",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "WaitOver",
		'name', "And Over",
		'help', "If any of the specified banters are still playing, they will be considered unplayed.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if not self.Negate then
				return Untranslated("If any of banter(s) played: ").. Untranslated(table.concat(self.Banters, ", "))
			else
				return Untranslated("None of banter(s) have played: ").. Untranslated(table.concat(self.Banters, ", "))
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not g_ActiveBanters then return false end
			
			local hasPlayed = false
			for i, banter in ipairs(self.Banters) do
				if g_BanterCooldowns[banter] then
					hasPlayed = banter
					break
				end
			end
			
			if self.WaitOver and g_ActiveBanters[hasPlayed] then
				hasPlayed = false
			end
			return hasPlayed
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return false
		end,
		'TestObject', PlaceObj('BanterHasPlayed', {
			Banters = {
				"IlleMoratMarauders_approach",
			},
		}),
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"BanterFunctionObjectBase",
	},
	group = "Conditions",
	id = "BanterIsPlaying",
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if a banter is currently playing. Useful for repeatable effects. For one time effects use BanterHasPlayed.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Banter",
	}),
	PlaceObj('PropertyDefPresetIdList', {
		'id', "Banters",
		'name', "Banters",
		'help', "List of banters to check.",
		'preset_class', "BanterDef",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if not self.Negate then
				return Untranslated("If any of banter(s) are currently playing: ").. Untranslated(table.concat(self.Banters, ", "))
			else
				return Untranslated("None of banter(s) are currently playing: ").. Untranslated(table.concat(self.Banters, ", "))
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local isPlaying = false
			
			for _, bantPlaying in ipairs(g_ActiveBanters) do
				local idx = table.find(self.Banters, bantPlaying.preset.id)
				if idx then
					isPlaying = true
					break
				end
			end
			
			return isPlaying
		end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('BanterIsPlaying', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "CheckIsPersistentUnitDead",
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Is unit with persistent id <u(per_ses_id)> dead",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a unit with a given persistent id is dead",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Unit with persistent id <u(per_ses_id)> is NOT dead",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "per_ses_id",
		'name', "per_ses_id",
		'items', function (self) return GetPersistentSessionIds() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local unitList = g_PersistentUnitData and g_PersistentUnitData[self.per_ses_id]
			if not unitList then return false end
			for i, u in ipairs(unitList) do
				if u:IsDead() then
					return true
				end
			end
			return false
		end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('CheckIsPersistentUnitDead', {
			per_ses_id = "NPC_Pierre",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "CheckSatelliteTimeRange",
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Checks if current satellite time is between two values [<u(TimeMinH)> , <u(TimeMaxH)>) expressed in hours <u(StartPoint)>.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the game time matches an interval.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "StartPoint",
		'default', "FromCampaignStart",
		'items', function (self) return {"FromCampaignStart", "WithinDay"} end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "TimeMinH",
		'name', "Min Time",
		'help', "in hours",
		'default', 0,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "TimeMaxH",
		'name', "Max Time",
		'help', "in hours",
		'default', 1,
		'min', 1,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not Game.CampaignTimeStart then return false end
			local min, max = self.TimeMinH, self.TimeMaxH
			local onStartPassedHours = GetTimeAsTable(Game.CampaignTimeStart).hour
			local passedHoursFromStart = (Game.CampaignTime - Game.CampaignTimeStart) / const.Scale.h 
			local passedHours = onStartPassedHours + passedHoursFromStart
			if self.StartPoint == "FromCampaignStart" then
				return passedHours >= min and passedHours < max
			elseif self.StartPoint == "WithinDay" then
				local passedHoursPerDay = passedHours % 24
				return passedHoursPerDay >= min and passedHoursPerDay < max
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TimeMinH and not self.TimeMaxH then
				return "No time restriction specified"
			end
			if not self.StartPoint then
				return "No Start Point specified"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'TestObject', PlaceObj('CheckSatelliteTimeRange', {
			StartPoint = "WithinDay",
			TimeMaxH = 7,
			TimeMinH = 5,
		}),
	}),
})

PlaceObj('ConditionDef', {
	id = "CityHasLoyalty",
	PlaceObj('PropertyDefChoice', {
		'id', "City",
		'help', "Check loyalty of the specified city.",
		'items', function (self) return table.map(GetCurrentCampaignPreset().Cities, "Id") end,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Condition",
		'help', "The comparison to perform.",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'help', "Compare loyalty to this value.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if city <u(City)> loyalty is <u(Condition)><Amount>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks the loyalty of a specific city",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local loyalty = GetCityLoyalty(self.City)
			return self:CompareOp(loyalty, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Condition then
				return "Missing Condition"
			elseif not self.Amount then
				return "Missing Amount"
			elseif not self.City then
				return "Missing City"
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetUIText",
		'params', "context, template, game",
		'code', function (self, context, template, game)
			local cityname = ""
			cityname = gv_Cities and self.City and gv_Cities[self.City] and gv_Cities[self.City].DisplayName or not game and Untranslated("[CityName]") or ""
			if self.Condition=="<" or self.Condition=="<=" then
				return T{834231644194, "Low Loyalty with <em><city_name></em>", city_name = cityname or ""}
			elseif self.Condition==">" or self.Condition==">=" or self.Condition=="=="  then
				return T{595954628454, "High Loyalty with <em><city_name></em>", city_name = cityname or ""}
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return false
		end,
		'TestObject', PlaceObj('CityHasLoyalty', {
			Amount = 67,
			City = "ErnieVillage",
			Condition = ">=",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "CiviliansKilled",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to the specified value.",
		'default', ">=",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:CompareOp(gv_CiviliansKilled, context)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If the player has killed <u(Condition)> <u(Amount)> civilians.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If the player has NOT killed <u(Condition)> <u(Amount)> civilians.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks the amount of civilians the player has killed.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Amount then
				return "Specify the param amount"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('CiviliansKilled', {
			Amount = 3,
			Condition = "<",
		}),
	}),
})

PlaceObj('ConditionDef', {
	id = "CombatIsActive",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if combat in progress",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if no combat in progress",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return g_Combat
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks for an active combat (turn-based mode).",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Combat",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('CombatIsActive', {}),
	}),
})

PlaceObj('ConditionDef', {
	id = "CombatTaskIsActive",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "task",
		'preset_class', "CombatTask",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "translate",
		'value', T(398644474618, --[[ConditionDef Conditions CombatTaskIsActive value]] "Combat Task <task> is active"),
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "translate",
		'value', T(513140382165, --[[ConditionDef Conditions CombatTaskIsActive value]] "Combat Task <task> is not active"),
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if specified CombatTask is currently active for any unit",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self.task and FindActiveCombatTask(self.task)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Combat",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('CombatTaskIsActive', {
			task = "DamageDealer",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "CombatTurn",
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Combat Turn <Condition> <Amount>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks the current turn in combat",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Combat",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Condition",
		'name', "Condition",
		'default', "==",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'default', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not g_Combat then return false end
			return self:CompareOp(g_Combat.current_turn, context)
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('CombatTurn', {
			Amount = 1,
		}),
	}),
})

PlaceObj('ConditionDef', {
	id = "EmailIsRead",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(emailId)> email is read.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If <u(emailId)> email is NOT read.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if an Email is read.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local emailReceived = gv_ReceivedEmails[self.emailId]
			return emailReceived and GetReceivedEmail(self.emailId).read
		end,
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "emailId",
		'name', "Email Id",
		'preset_class', "Email",
		'preset_filter', function (preset, obj, prop_meta)
			return not preset.repeatable
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.emailId then
				return "Specify an Email"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('EmailIsRead', {
			emailId = "Spam_1",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "EnemySquadInSector",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'help', "Sector id.",
		'items', function (self) return GetCampaignSectorsCombo() end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "An enemy squad is in <u(sector_id)> sector",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "No enemy squad is in <u(sector_id)> sector",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id
			return gv_Sectors[sector_id] and not gv_Sectors[sector_id].conflict and #GetSectorSquadsFromSide(sector_id,"enemy1","enemy2") > 0
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if any type of enemy squad is in control of a given sector (meaning enemy control - no conflict and there's an enemy squad in that sector)",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('EnemySquadInSector', {
			sector_id = "A1",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "EvalForEachUnitInSector",
	PlaceObj('PropertyDefCombo', {
		'id', "Sector",
		'help', "Game sector to test.",
		'default', "A1",
		'items', function (self) return GetCampaignSectorsCombo() end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "CheckFor",
		'name', "Valid for units",
		'help', "Conditions are true for 'all' or 'any' of mercs in that sector.",
		'default', "any",
		'items', function (self) return {"all", "any"} end,
	}),
	PlaceObj('PropertyDefNestedList', {
		'id', "Conditions",
		'name', "Conditions",
		'help', "Conditions to evaluate.",
		'base_class', "Condition",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local conditions =  self.Conditions
			if not conditions or #conditions == 0 then
				return true
			end
			if not context then context = {} end
			context.is_sector_unit = true
			context.target_units = {}
			local check_for = self.CheckFor
			
			local squads = GetSquadsInSector(self.Sector)
			for i, squad in ipairs(squads) do
				for j, unit_id in ipairs(squad.units) do
					local unit = gv_UnitData[unit_id]
					context.target_units[1] = unit
					if _EvalConditionList(conditions, unit, context) then
						if check_for == "any" then
							context.is_sector_unit = false
							return true
						end
					else
						if check_for == "all" then
							context.is_sector_unit = false
							return false
						end
					end
				end
			end
			context.is_sector_unit = false
			return check_for == "all"
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', 'For each unit in each squad in the given sector, evaluates the nested conditions in order, evaluating to true if all of them evaluate to true. Target unit conditions must be with TargetUnit = "current unit"',
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if for <u(CheckFor)> units from sector '<u(Sector)>' all conditions are true.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if for <u(CheckFor)> units from sector '<u(Sector)>' at least one condition is false.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('EvalForEachUnitInSector', {
			CheckFor = "all",
			Conditions = {
				PlaceObj('CityHasLoyalty', {
					Amount = 10,
					City = "ErnieVillage",
					Condition = ">=",
				}),
			},
		}),
	}),
})

PlaceObj('ConditionDef', {
	id = "GroupIsDead",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Group",
		'name', "Group",
		'help', "",
		'default', "false",
		'items', function (self) return GetUnitGroups() end,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Mode",
		'default', "all",
		'items', function (self) return { "all", "any" } end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(Mode)> from <u(Group)> are dead.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if not <u(Mode)> from <u(Group)> are dead",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if there are dead units from the group on the map",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			-- Check in GameVar DeadGroupsInSectors
			local deadGroups = DeadGroupsInSectors[gv_CurrentSectorId]
			local gameVarResult = deadGroups and deadGroups[self.Group]
			
			if gameVarResult then
				if self.Mode == "any" then
					return gameVarResult == "any" or gameVarResult == "all"
				elseif self.Mode == "all" then
					return gameVarResult == "all"
				end
			end
			
			-- Nothing in GameVar(all allive or no info collected)
			-- Check in MapVar Groups
			local mapVarResult
			local dead, alive = 0, 0
			for _, obj in ipairs(Groups[self.Group]) do
				if IsKindOf(obj, "Unit") then
					if obj:IsDead() then
						dead = dead + 1
					else
						alive = alive + 1
					end
				end
			end
			
			if dead > 0 then
				if alive > 0 then
					mapVarResult = "any"
				else
					mapVarResult = "all"
				end
			end
			
			if mapVarResult then
				if self.Mode == "any" then
					return mapVarResult == "any" or mapVarResult == "all"
				elseif self.Mode == "all" then
					return mapVarResult == "all"
				end
			end
			
			return false
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('GroupIsDead', {
			Group = "Raiders",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "GuardpostObjectiveDone",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return IsGuardpostObjectiveDone(self.GuardpostObjective)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If guardpost objective <u(GuardpostObjective)> is completed",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If guardpost objective <u(GuardpostObjective)> is NOT completed",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a guardpost objective has been completed.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "GuardpostObjective",
		'name', "GuardpostObjective",
		'preset_class', "GuardpostObjective",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('GuardpostObjectiveDone', {
			GuardpostObjective = "WaterWell",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "InteractableHasVisualObjects",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "InteractableGroup",
		'help', "The group of the interactable",
		'default', "false",
		'items', function (self) return table.keys(Groups) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "StoreAsTable",
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Can be used to detect if visuals of an interactable were destroyed etc.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local group = Groups[self.InteractableGroup]
			for i, int in ipairs(group) do
				if IsKindOf(int, "Interactable") then
					local visual = ResolveInteractableVisualObjects(int, nil, nil, "findFirst")
					if visual then
						return true
					end
					return false
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(InteractableGroup)>' has visual objects",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(InteractableGroup)>' doesn't have visual objects",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Interactions",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('InteractableHasVisualObjects', {
			'Negate', true,
			'InteractableGroup', "12Chairs_ChairMarker",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "InteractingMercHasItem",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "ItemId",
		'items', function (self) return ClassDescendantsCombo("InventoryItem") end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Equipped",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If the merc interacting with this has an item of class <u(ItemId)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If the merc interacting with this doesn't have an item of class <u(ItemId)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "If the merc interacting with an interactable has an item of a specific class",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local unit = context and context.target_units
			unit = unit and unit[1]
			if not unit then return false end
			
			local has = false
			if self.Equipped then
				has = unit:GetItemInSlot("Handheld A", self.ItemId) or
							unit:GetItemInSlot("Handheld B", self.ItemId)
			else
				has = unit:GetItemInSlot("Inventory", self.ItemId)
			end
			
			return has
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.ItemId then
				return "Set Item!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)  end,
		'TestObject', PlaceObj('InteractingMercHasItem', {
			ItemId = "MacheteWeapon",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "IsCurrentMap",
	PlaceObj('PropertyDefCombo', {
		'id', "MapFile",
		'default', "",
		'items', function (self) return ListMaps() end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if currently in tactical view on the specified map",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView or not gv_Sectors then return false end
			
			local sectorPreset = gv_Sectors[gv_CurrentSectorId]
			if sectorPreset then
				return sectorPreset.Map == self.MapFile
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.MapFile then
				return "specify map!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('IsCurrentMap', {
			MapFile = "I-1 - Flag Hill",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Currently in tactical view in <u(MapFile)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Currently not in tactical view in <u(MapFile)>",
		'untranslated', true,
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "IsDayOfTheWeek",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			--%w - Weekday as decimal number (1 - 7; Sunday is 1)
			local actualDay
			if self.WDay and self.WDay == 7 then
				 actualDay = 1
			elseif self.WDay then
				actualDay = self.WDay  + 1
			end
			return GetTimeAsTable(Game.CampaignTime).wday == actualDay
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Current day is <day_name_number(WDay)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Current day is not <day_name_number(WDay)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Used to check which day of the week the current day is (1 - Monday etc)",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "WDay",
		'name', "Day of the Week",
		'default', 1,
		'min', 1,
		'max', 7,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('IsDayOfTheWeek', {
			WDay = 3,
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "IsSectorOperationStarted",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "operation",
		'name', "Operation",
		'help', "Operation to check",
		'items', function (self) return table.keys(SectorOperations) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector has Operation <u(operation)> in progress",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector does not have Operation <u(operation)> in progress",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			local mercs = GetPlayerSectorUnits(sector_id)
			for _, merc in ipairs(mercs) do
				if merc.Operation == self.operation then
					return true
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the specified operation is being perfomed by a merc in the sector",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.operation then
				return "Specify operation!"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('IsSectorOperationStarted', {
			operation = "HospitalTreatmentCustom",
			sector_id = "A10",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "IsTimeOfDay",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local timeOfDay = CalculateTimeOfDay(Game.CampaignTime)
			return timeOfDay == self.TimeOfDay
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Time of day is <u(TimeOfDay)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Time of day is not <u(TimeOfDay)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Used to check the time of day.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "TimeOfDay",
		'default', "Day",
		'items', function (self) return { "Day", "Night", "Sunrise", "Sunset" } end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('IsTimeOfDay', {
			TimeOfDay = "Night",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "ItemIsFound",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Sector",
		'name', "Sector Id",
		'help', "Sector id",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"},{text = "all sectors", value = "all_sectors"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "ItemId",
		'name', "Item",
		'help', "Item id that is looked for.",
		'preset_class', "InventoryItemCompositeDef",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'name', "Amount",
		'help', "Amount of that item.",
		'default', 1,
		'min', 1,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "eval_count",
		'name', "eval_count",
		'help', "Amount of that item.",
		'dont_save', true,
		'no_edit', true,
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if any merc or opened container in <u(Sector)> sector  has <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if any merc or opened container in <u(Sector)> sector haven't <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "if the item is in any merc or opened container in that sector",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			-- sector
			local sector_id =  self.Sector
			if self.Sector == "current" then
				sector_id = gv_CurrentSectorId
			end
			-- units has item
			self.eval_count = nil
			local squads = GetSquadsInSector(sector_id)
			for i, squad in ipairs(squads) do
				for j, unit_id in ipairs(squad.units) do
					local unit = gv_UnitData[unit_id]
					unit:ForEachItemDef(self.ItemId, function(item, slot, self)
						self.eval_count = self.eval_count + (IsKindOf(item, "InventoryStack") and item.Amount or 1)
						if self.eval_count >= self.Amount then
							return "break"
						end
					end, self)
					if self.eval_count >= self.Amount then
						return true
					end
				end
			end
			local amount = self.eval_count
			self.eval_count = nil
			-- sector opened containers has item
			return SectorContainersHasItem(sector_id, self.ItemId, amount)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.ItemId then
				return "Set Item!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('ItemIsFound', {
			ItemId = "_44CAL_Match",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "ItemIsInMerc",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Sector",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"},{text = "all sectors", value = "all_sectors"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "ItemId",
		'name', "Item",
		'help', "Item id that is looked for.",
		'preset_class', "InventoryItemCompositeDef",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'name', "Amount",
		'help', "Amount of that item.",
		'default', 1,
		'min', 1,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if any merc in <u(Sector)> sector  has <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if any merc  in <u(Sector)> sector haven't <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "if the item is in any merc in that sector",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "eval_count",
		'name', "eval_count",
		'help', "Amount of that item.",
		'dont_save', true,
		'no_edit', true,
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			-- sector
			local sector_id =  self.Sector
			if self.Sector == "current" then
				sector_id = gv_CurrentSectorId
			end
			-- units has item
			self.eval_count = nil
			local squads = self.Sector == "all_sectors" and GetPlayerMercSquads() or GetSquadsInSector(sector_id)
			for i, squad in ipairs(squads) do
				for j, unit_id in ipairs(squad.units) do
					local unit = gv_UnitData[unit_id]
					unit:ForEachItemDef(self.ItemId, function(item, slot, self)
						self.eval_count = self.eval_count + (IsKindOf(item, "InventoryStack") and item.Amount or 1)
						if self.eval_count >= self.Amount then
							return "break"
						end
					end, self)
					if self.eval_count >= self.Amount then
						self.eval_count = nil
						return true
					end
				end
			end
			self.eval_count = nil
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.ItemId then
				return "Set Item!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)  end,
		'TestObject', PlaceObj('ItemIsInMerc', {
			Amount = 2,
			ItemId = "MP40",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionCombatParticipate",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
			"UnitData",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If merc fought in <u(PresetValue)> conflicts in the past <Days> days.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the merc participated in a conflict in the last X days.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local mercId = obj.session_id
			local conflicts = GetMercConflictsParticipatedWithinLastDays(mercId, self.Days, "unique")
			-- todo: check substr and convert to number?
			if self.PresetValue == "<=3" then
				return conflicts <= 3
			elseif self.PresetValue == "=>10" then
				return conflicts >= 10
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Days",
		'name', "Days",
		'no_edit', true,
		'default', 14,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "PresetValue",
		'name', "PresetValue",
		'default', "<=3",
		'items', function (self) return { { name = "low (<=3)", value = "<=3" }, { name = "high (>=10)", value = ">=10" }, } end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return gv_UnitData.Raider
		end,
		'TestObject', PlaceObj('MercChatConditionCombatParticipate', {
			PresetValue = ">=10",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionDeathToll",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(PresetValue)> dead mercs in last <Days> days.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local timeNow = Game and Game.CampaignTime or 0
			local deadMercs = 0
			local lastDaysInMs = self.Days * const.Scale.day
			
			ForEachMerc(function(mId)
				local ud = gv_UnitData and gv_UnitData[mId]
				if ud and ud.HireStatus == "Dead" then
					local deathTime = ud.HiredUntil
					if timeNow - deathTime < lastDaysInMs then
						deadMercs = deadMercs + 1
					end
				end
			end)
			
			local deadMercsCond = self.PresetValue
			if deadMercsCond == "2+" then
				return deadMercs >= 2
			else
				deadMercsCond = tonumber(deadMercsCond) or 0
				return deadMercs == deadMercsCond
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Days",
		'name', "Days",
		'no_edit', true,
		'default', 14,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "PresetValue",
		'name', "PresetValue",
		'default', "0",
		'items', function (self) return { { name = "good (0)", value = "0" }, { name = "moderate (1)", value = "1" }, { name = "high (2+)", value = "2+" } } end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return MercChatRefusal:new()
		end,
		'TestObject', PlaceObj('MercChatConditionDeathToll', {
			PresetValue = "1",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionLateRenew",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
			"UnitData",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If player is trying to renew contract when less than a day is left.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if obj.HireStatus ~= "Hired" then return false end
			local contractLeft = obj.HiredUntil - Game.CampaignTime
			return contractLeft <  const.Scale.day
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return gv_UnitData.Raven
		end,
		'TestObject', PlaceObj('MercChatConditionLateRenew', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionMoney",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
			"UnitData",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If player has <u(PresetValue)> money.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local money = Game.Money
			
			-- todo: check substr and convert to number?
			if self.PresetValue == "<=10" then
				return money <= 10000
			elseif self.PresetValue == ">=50" then
				return money >= 50000
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "PresetValue",
		'name', "PresetValue",
		'default', "<=10",
		'items', function (self) return { { name = "low (<=10k)", value = "<=10" }, { name = "high (>=50k)", value = ">=50" }, } end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return gv_UnitData.Raider
		end,
		'TestObject', PlaceObj('MercChatConditionMoney', {
			PresetValue = ">=50",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionRehire",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
			"UnitData",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If player has <u(PresetValue)> contracts/extensions with the merc.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local mercId = obj.session_id
			local contracts = GetMercStateFlag(mercId, "HireCount") or 0
			if self.PresetValue == "0" and contracts == 0 then return true end
			if self.PresetValue == "1-2" and contracts >= 1 and contracts <= 2 then return true end
			if self.PresetValue == "5+" and contracts >= 5 then return true end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "PresetValue",
		'name', "PresetValue",
		'default', "0",
		'items', function (self) return { { name = "none", value = "0" }, { name = "low (1-2)", value = "1-2" }, { name = "high (5+)", value = "5+" } } end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return gv_UnitData.Raider
		end,
		'TestObject', PlaceObj('MercChatConditionRehire', {
			PresetValue = "5+",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "MercChatConditionWhim",
	PlaceObj('ClassConstDef', {
		'name', "RequiredObjClasses",
		'type', "string_list",
		'value', {
			"MercChatBranch",
			"UnitData",
		},
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(PresetValue)>% chance. Rerolled once every <Days> days per merc.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local mercId = obj.session_id
			local dayHash = xxhash(mercId, (Game.CampaignTime / const.Scale.day) / self.Days, Game.id)
			local roll = 1 + BraidRandom(dayHash, 100)
			CombatLog("debug", "MercChatWhim rolled " .. roll)
			return roll < self.PresetValue
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Merc Chat",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Days",
		'name', "Days",
		'no_edit', true,
		'default', 1,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "PresetValue",
		'name', "PresetValue",
		'default', 20,
		'items', function (self) return { { name = "normal (20%)", value = 20 }, { name = "low (10%)", value = 10 }, { name = "high (50%)", value = 50 } } end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return gv_UnitData.Raider
		end,
		'TestObject', PlaceObj('MercChatConditionWhim', {}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "MercIsLikedDisliked",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local subject = self.TargetUnit
			local relation = self.Relation
			local object = self.Object
			
			if relation == "Likes" then
				if table.find(gv_UnitData[subject].Likes, object) then return true end
			elseif relation == "Dislikes" then
				if table.find(gv_UnitData[subject].Dislikes, object) then return true end
			end
			
			return false
		end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Relation",
		'name', "Relation",
		'help', "Choose to search in Likes or Dislikes",
		'default', "Likes",
		'items', function (self) return {"Likes", "Dislikes"} end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Object",
		'name', "Object",
		'items', function (self) return MercPresetCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if self.Negate then
				return T{Untranslated("if '<u(TargetUnit)>' NOT '<u(relation)>' '<u(Object)>'."), Object =  self.Object, relation = self.Relation }
			else
				return T{Untranslated("if '<u(TargetUnit)>'  '<u(relation)>' '<u(Object)>'."), Object =  self.Object, relation = self.Relation}
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a specific merc has another one in his Likes/Dislikes tables.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TargetUnit then
				return "Specify the object"
			end
			if not self.Object then
				return "Specify the subject"
			end
			if not self.Relation then
				return "Specify the relation"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('MercIsLikedDisliked', {
			Negate = true,
			Object = "Fox",
			Relation = "Dislikes",
			TargetUnit = "Wolf",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerControlCities",
	PlaceObj('PropertyDefCombo', {
		'category', "General",
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to player cities count.",
		'default', ">",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
		'min', 0,
	}),
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "CitySectors",
		'help', "Count number of sectors that belong to any city rather than unique cities.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local cityCount = GetPlayerCityCount(self.CitySectors)
			return self:CompareOp(cityCount)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Player cities <u(Condition)> <Amount>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks player cities count",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerControlCities', {
			Amount = 1,
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerControlSectors",
	PlaceObj('PropertyDefChoice', {
		'id', "POIs",
		'name', "Required POIs",
		'help', "Only sectors which contain the POIs specified will be counted; choose 'all' to count all sectors.",
		'default', "all",
		'items', function (self) return GetSectorPOITypes() end,
	}),
	PlaceObj('PropertyDefCombo', {
		'category', "General",
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to matching sectors count.",
		'default', ">",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if self.POIs == "all" then
				return Untranslated("Player sectors <u(Condition)> <Amount>")
			else
				return Untranslated(string.format("Player sectors with %s =<u(Condition)> <Amount>", self.POIs))
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:CompareOp(gv_PlayerSectorCounts[self.POIs] or 0)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks player sectors matching the specified POIs count",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerControlSectors', {
			POIs = "Guardpost",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerHasALowHealthMerc",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then
				for _, squad in ipairs(g_SquadsArray) do
					if squad.Side == "player1" then
						for i, u in ipairs(squad.units or empty_table) do
							if gv_UnitData[u] and gv_UnitData[u].HitPoints < gv_UnitData[u].MaxHitPoints then
								return true
							end
						end
					end
				end
			else
				for _, team in ipairs(g_Teams) do 
					if team.side == "player1" then 
						for _, u in ipairs(team.units) do
							if u.HitPoints < u.MaxHitPoints then
								return true
							end
						end
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Player has a merc that is not in full health",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "All player mercs are at full health",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the player has at least one merc that is not on full health",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerHasALowHealthMerc', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerHasAWoundedMerc",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then
				for _, squad in ipairs(g_SquadsArray) do
					if squad.Side == "player1" then
						for i, u in ipairs(squad.units or empty_table) do
							local unit = gv_UnitData[u]
							local idx = unit:HasStatusEffect("Wounded")
							if idx and unit.StatusEffects[idx].stacks>0 then
								return true
							end
						end
					end
				end
			else
				for _, team in ipairs(g_Teams) do 
					if team.side == "player1" then 
						for _, unit in ipairs(team.units) do
							local idx = unit:HasStatusEffect("Wounded")
							if idx and unit.StatusEffects[idx].stacks>0 then
								return true
							end
						end
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', 'Player has a merc with at least 1 stack of "Wounded" character effect',
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "All player mercs are not wounded",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the player has at least one wounded merc",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerHasAWoundedMerc', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerHasMoney",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'category', "General",
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to the specified value.",
		'default', ">=",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:CompareOp(Game.Money, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetUIText",
		'params', "context",
		'code', function (self, context)
			--[[if self.Negate then
				return  T{222544399443, "<money(Amount)> required", Amount = self.Amount}
			else
				return  T{982094780061, "Give <money(Amount)>", Amount = self.Amount}
			end
			--]]
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if player's money <u(Condition)> <money(Amount)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if player's money are not <u(Condition)> <money(Amount)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks the amount of money that the player has.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Amount then
				return "Specify the param amount"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerHasMoney', {
			Amount = 110,
			Negate = true,
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerIsInSectors",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition",
	}),
	PlaceObj('PropertyDefStringList', {
		'id', "Sectors",
		'name', "Sectors",
		'help', "Check if the game play is in that sector.",
		'item_default', "A1",
		'items', function (self) return GetCampaignSectorsCombo() end,
		'default', {
			"A1",
		},
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return not gv_SatelliteView and gv_CurrentSectorId and table.find(self.Sectors, gv_CurrentSectorId)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if self.Negate then 
				return T{672591083408, "if NOT in any of sectors {<u(text)>}", text = table.concat(self.Sectors, ", ")}
			else
				return T{484570727486, "if in any of sectors {<u(text)>}", text = table.concat(self.Sectors, ", ")}
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the game play is in any of sectors.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return  selo()
		end,
		'TestObject', PlaceObj('PlayerIsInSectors', {
			Sectors = {
				"A1",
				"A15",
			},
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerIsInSectorsOfTier",
	PlaceObj('PropertyDefBool', {
		'id', "UpTo",
		'default', true,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "MapTier",
		'name', "MapTier",
		'default', 0,
		'scale', 10,
		'step', 5,
		'min', 0,
		'max', 50,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then return false end
			
			local sector = gv_Sectors[gv_CurrentSectorId]
			if not sector then return false end
			
			local sectorTier = sector.MapTier
			if self.UpTo then
				return sectorTier <= self.MapTier
			end
			
			return sectorTier == self.MapTier
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if self.UpTo then 
				return T{Untranslated("if in sector of tier <FormatScale(MapTier, 10)> or lower"), self}
			else
				return T{Untranslated("If in sector of tier <FormatScale(MapTier, 10)>"), self}
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if in tactical view on a sector of a specific tier.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return  selo()
		end,
		'TestObject', PlaceObj('PlayerIsInSectorsOfTier', {
			MapTier = 20,
			UpTo = false,
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerIsPlayerTurn",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return g_Combat and g_Combat.start_reposition_ended and IsNetPlayerTurn()
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if player's turn in combat",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if not player's turn in combat",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks  it is the player's turn in combat",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Combat",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('PlayerIsPlayerTurn', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "PlayerSquadPresentInSectors",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Sector",
		'name', "Sector",
		'default', "I1",
		'items', function (self) return GetCampaignSectorsCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local playerSquadsHere = GetSquadsInSector(self.Sector, false, false, true)
			return #playerSquadsHere > 0
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if self.Negate then 
				return T{736317896521, "if player has NO squad in sector {<u(text)>}", text = self.Sector}
			else
				return T{572189738813, "if player has a squad in sector {<u(text)>}", text = self.Sector}
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the player has a squad in the specified sector",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return  selo()
		end,
		'TestObject', PlaceObj('PlayerSquadPresentInSectors', {
			Sector = "G6",
		}),
	}),
})

PlaceObj('ClassDef', {
	DefParentClassList = {
		"Condition",
		"QuestFunctionObjectBase",
	},
	group = "Conditions",
	id = "QuestConditionBase",
	PlaceObj('ClassMethodDef', {
		'name', "OnAfterEditorNew",
		'params', "obj, socket, paste",
		'code', function (self, obj, socket, paste)
			if not paste then
				local quest_def = GetParentTableOfKindNoCheck(self, "QuestsDef")
				if quest_def then
					self.QuestId = quest_def.id
				end
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Quests",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"QuestConditionBase",
	},
	group = "Conditions",
	id = "QuestHasTimerPassed",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId",
		'name', "Quest id",
		'help', "Quest to check.",
		'preset_class', "QuestsDef",
		'preset_filter', function (preset, obj, prop_meta)
			return QuestHasVariable(preset, "QuestVarNum")
		end,
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "TimerVariable",
		'help', "Quest variable to check.",
		'items', function (self) return GetQuestsVarsCombo(self.QuestId, "Num") end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if #(self.QuestId or "") == 0  or not self.TimerVariable then return false end
			local quest = QuestGetState(self.QuestId or "")
			local timerVal = rawget(quest, self.TimerVariable)
			
			-- Special check for when the timer is unset
			if not timerVal or timerVal == 0 then return false end
			return timerVal < Game.CampaignTime
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(TimerVariable)>:<u(QuestId)> has not passed.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(TimerVariable)>:<u(QuestId)> has passed.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Tests whether a timer set by QuestSetVariableTimer has passed.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.QuestId or self.QuestId=="" then
				return "Specify the quest!"
			end
			if not self.TimerVariable then
				return "Specify the variable which holds the timer! Can be set via QuestSetVariableTimer"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestHasTimerPassed', {
			QuestId = "04_Betrayal",
			TimerVariable = "EmmaTimer",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"QuestConditionBase",
	},
	group = "Conditions",
	id = "QuestIsTCEState",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId",
		'name', "Quest id",
		'help', "Quest to check.",
		'preset_class', "QuestsDef",
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Prop",
		'name', "Quest Variable",
		'help', "Quest TCE to check",
		'items', function (self) return GetQuestsVarsCombo(self.QuestId, "TCEState") end,
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Value",
		'name', "Value",
		'help', "Possible TCEState values to check for.",
		'items', function (self) return {true, false, "done"} end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.QuestId or self.QuestId==""  or not self.Prop then return false end
			local quest = QuestGetState(self.QuestId or "")
			local val = rawget(quest,self.Prop)
			return  val == self.Value
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Test value of TCEState quest variable",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.QuestId or self.QuestId=="" then
				return "Specify the quest!"
			end
			if not self.Prop then
				return "Specify the TCE state variable to check!"
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			local value = self.Value
			if value == true and not self.Negate or value == false and self.Negate then
				return Untranslated("if <u(Prop)> (<u(QuestId)>)")
			elseif value == false and not self.Negate or value == true and self.Negate then
				return Untranslated("if not <u(Prop)> (<u(QuestId)>)")
			end
			assert( value == "done" )
			if self.Negate then
				return Untranslated("if <u(Prop)> ~= done (<u(QuestId)>)")
			else
				return Untranslated("if <u(Prop)> == done (<u(QuestId)>)")	
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestIsTCEState', {
			Prop = "QuestSelfKill",
			QuestId = "LegionFlag",
			Value = "done",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"QuestConditionBase",
	},
	group = "Conditions",
	id = "QuestIsVariableBool",
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId",
		'name', "Quest id",
		'help', "Quest to check.",
		'preset_class', "QuestsDef",
		'preset_filter', function (preset, obj, prop_meta)
			return QuestHasVariable(preset, "QuestVarBool")
		end,
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Condition",
		'help', 'The "and" value checks whether all variables have the specified value; "or" checks whether any of them has it.',
		'default', "and",
		'items', function (self) return { "and", "or" } end,
	}),
	PlaceObj('PropertyDefSet', {
		'category', "General",
		'id', "Vars",
		'name', "Vars to check",
		'help', "Click on a variable to turn it green, click again to turn it red. The condition will check if all of the green are true AND all of the red are false.",
		'items', function (self) return table.keys2(QuestGetVariables(self.QuestId), "sorted") end,
		'three_state', true,
	}),
	PlaceObj('PropertyDefFunc', {
		'id', "__eval",
		'read_only', true,
		'default', function (self)
			if not self.QuestId or self.QuestId=="" or not self.Vars or not next(self.Vars) then return false end
			local quest = QuestGetState(self.QuestId or "")
			local first_var = next(self.Vars)
			if next(self.Vars, first_var) == nil then -- only check one var, reduce to simple lookup
				local value = rawget(quest, first_var)
				if self.Vars[first_var] then
					return not not value
				else  -- set self.Vars holds false for vars that should be negated
					return not value
				end
			end
			if self.Condition == "and" then
				for var, condition in pairs(self.Vars) do
					local val = rawget(quest, var)
					if condition == true then -- check for var
						if not val then return false end
					else -- check for NOT var
						if val then return false end
					end
				end
				return true
			else
				for var, condition in pairs(self.Vars) do
					local val = rawget(quest, var)
					if condition == true then -- check for var
						if val then return true end
					else -- check for NOT var
						if not val then return true end
					end
				end
				return false
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Test value of bool quest variable",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.QuestId or self.QuestId=="" then
				return "Specify the quest!"
			end
			if not self.Vars or not next(self.Vars) then
				return "Specify the vars to check!"
			end
			if self.Negate then
				return "Use per-var negation via the Vars property instead of Negate!"
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if not self.Vars or not next(self.Vars) then
				return Untranslated("(no vars selected to check)")
			end
			
			local vars = {}
			for var, condition in sorted_pairs(self.Vars) do
				vars[#vars+1] = condition and var or ("not " .. var)
			end
			vars = table.concat(vars, " " .. self.Condition .. " ")
			
			if self.Negate then
				return Untranslated("if not (" .. vars .. ") (<u(QuestId)>)")
			else
				return Untranslated("if " .. vars .. " (<u(QuestId)>)")	
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "OnEditorSetProperty",
		'params', "prop_id, old_value, ged",
		'code', function (self, prop_id, old_value, ged)
			if prop_id=="QuestId" then
				self.Vars = nil
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "OnPreSave",
		'code', function (self)
			if not next(self.Vars) then
				self.__eval = empty_func
				return
			end
			
			local checks = {}
			for var, condition in sorted_pairs(self.Vars) do
				local format = var:match("^[%a_][%w_]*$") and "%squest.%s" or "%squest['%s']"
				table.insert(checks, string.format(format, condition and "" or "not ", var))
			end
			
			local quest = self.QuestId or ""
			local code = string.format("local quest = gv_Quests['%s'] or QuestGetState('%s')\n", quest, quest)
			local cond = string.format(" %s ", self.Condition)
			code = code .. string.format("return %s", table.concat(checks, cond))
			self.__eval = CompileFunc("__eval", "", code)
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestIsVariableBool', {
			Condition = "or",
			QuestId = "01_Landing",
			Vars = {
				Luc_attitude = false,
				Luc_rude = false,
			},
			__eval = function ()
				local quest = gv_Quests['01_Landing'] or QuestGetState('01_Landing')
				return not quest.Luc_attitude or not quest.Luc_rude
			end,
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"QuestConditionBase",
	},
	group = "Conditions",
	id = "QuestIsVariableNum",
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId",
		'name', "Quest id",
		'help', "Quest to check.",
		'preset_class', "QuestsDef",
		'preset_filter', function (preset, obj, prop_meta)
			return QuestHasVariable(preset, "QuestVarNum")
		end,
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Prop",
		'name', "Quest Variable",
		'help', "Quest variable to check.",
		'items', function (self) return GetQuestsVarsCombo(self.QuestId, "Num") end,
	}),
	PlaceObj('PropertyDefCombo', {
		'category', "General",
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to the specified value.",
		'default', ">=",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "AgainstVar",
		'name', "Against variable",
		'help', "Check to compare with another quest variable.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId2",
		'name', "Quest id",
		'help', "Quest with variable to compare against.",
		'extra_code', "no_edit = function(self) return not self.AgainstVar end",
		'preset_class', "QuestsDef",
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Prop2",
		'name', "Quest Variable",
		'help', "Quest variable to compare against.",
		'extra_code', "no_edit = function(self) return not self.AgainstVar end",
		'items', function (self) return GetQuestsVarsCombo(self.QuestId2, "Num") end,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "Amount",
		'name', "Amount",
		'help', "Value to check against.",
		'extra_code', "no_edit = function(self) return self.AgainstVar end",
		'default', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.QuestId or self.QuestId==""  or not self.Prop then return false end
			local quest = QuestGetState(self.QuestId or "")
			local val = rawget(quest, self.Prop)
			local amount = self.Amount
			
			if self.AgainstVar then
				local quest2 = QuestGetState(self.QuestId2 or "")
				amount = rawget(quest, self.Prop2)
			end
			
			return val and self:CompareOp(val, context, amount)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			if not self.AgainstVar then
				return Untranslated("if <u(Prop)> <u(Condition)> <Amount>  (<u(QuestId)>)")
			end
			return Untranslated("if <u(Prop)>(<u(QuestId)>) <u(Condition)> <u(Prop2)>(<u(QuestId2)>) ")
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Tests the value of a numeric quest variable",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.QuestId or self.QuestId=="" then
				return "Specify the quest!"
			end
			if not self.Prop then
				return "Specify the param to check!"
			end
			if not self.Amount then
				return "Specify the param amount"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestIsVariableNum', {
			AgainstVar = true,
			Prop = "TestVarNum",
			Prop2 = "TestVarNum",
			QuestId = "_TestQuest",
			QuestId2 = "_TestQuest",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"QuestConditionBase",
	},
	group = "Conditions",
	id = "QuestIsVariableText",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'category', "General",
		'id', "QuestId",
		'name', "Quest id",
		'help', "Quest to check",
		'preset_class', "QuestsDef",
		'preset_filter', function (preset, obj, prop_meta)
			return QuestHasVariable(preset, "QuestVarText")
		end,
	}),
	PlaceObj('PropertyDefChoice', {
		'category', "General",
		'id', "Prop",
		'name', "Quest Variable",
		'help', "Quest variable to check.",
		'items', function (self) return GetQuestsVarsCombo(self.QuestId, "Text") end,
	}),
	PlaceObj('PropertyDefText', {
		'category', "General",
		'id', "Text",
		'name', "Text",
		'help', "Value to check for.",
		'default', "",
		'translate', false,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.QuestId or self.QuestId=="" or not self.Prop then return false end
			local quest = QuestGetState(self.QuestId or "")
			local val = rawget(quest,self.Prop)
			return val and val==self.Text
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(Prop)> == '<u(Text)>' (<u(QuestId)>)",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(Prop)> ~= '<u(Text)>' (<u(QuestId)>)",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Test value of text quest variable",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.QuestId or self.QuestId=="" then
				return "Specify the quest!"
			end
			if not self.Prop then
				return "Specify the param to check!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestIsVariableText', {
			Prop = "TestVarText",
			QuestId = "_TestQuest",
			Text = "test",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "QuestKillTCEsOnCompleted",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local quest_def = GetParentTableOfKind(self, "QuestsDef")
			if not quest_def then return false end
			local quest = QuestGetState(quest_def.id or "")
			return QuestIsBoolVar(quest,"Completed",true)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Kill TCEs check is on quest completed.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Quests",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			return Untranslated("if the quest is  \"completed\"")
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('QuestKillTCEsOnCompleted', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SatelliteGameplayRunning",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return gv_SatelliteView and not IsConflictMode()
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Is satellite gameplay running",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Is satellite gameplay not running",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the player is in satellite view and there is no conflict",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SatelliteGameplayRunning', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorCheckCity",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "city",
		'name', "City",
		'help', "Specify city.",
		'default', "ErnieVillage",
		'items', function (self) return table.map(GetCurrentCampaignPreset().Cities, "Id") end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector is a part of city <u(city)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector is not a part of city <u(city)>",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].City == self.city
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current sector is a part of the specified city",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorCheckCity', {
			sector_id = "H2",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorCheckOwner",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "owner",
		'name', "Owner",
		'help', "Specify owner.",
		'default', "any player",
		'items', function (self) return table.iappend( {"any player", "any enemy", }, Sides) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector is controlled by <u(owner)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector is not controlled by <u(owner)>",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			if not gv_Sectors[sector_id] or not GetCurrentCampaignPreset() then return end
			local sector_side = gv_Sectors[sector_id].Side
			if self.owner == "any player" then
				for _, side in ipairs(SideDefs) do
					if side.Player and side.Id == sector_side then
						return true
					end
				end
			elseif self.owner == "any enemy" then
				for _, side in ipairs(SideDefs) do
					if side.Enemy and side.Id == sector_side then
						return true
					end
				end
			end
			return sector_side == self.owner
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current sector is controlled by defined owner",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorCheckOwner', {}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorHasDepletedMine",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector has a depleted mine",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector does not have a depleted mine",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			local sector = gv_Sectors[sector_id]
			return sector and sector.Mine and sector.mine_depleted
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the specified sector has a depleted mine",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorHasDepletedMine', {
			sector_id = "A2",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorHasHospital",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector has a hospital",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector does not have a hospital",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].Hospital
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the specified sector has a hospital",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorHasHospital', {
			sector_id = "A1",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorHasIntel",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if <u(sector_id)> sector's intel is discovered",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(sector_id)> sector's intel isn't discovered",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].intel_discovered
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current or specified sector has its intel discovered.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorCheckCity', {
			sector_id = "H2",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorInWarningState",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(sector_id)> sector is currently in a warning state.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If <u(sector_id)> sector is NOT currently in a warning state.",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].inWarningState
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current or specified sector is currently in a warning state.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorInWarningState', {}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorIsInConflict",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if conflict in <u(sector_id)> sector",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if no conflict in <u(sector_id)> sector",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].conflict
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current sector is currently in conflict",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorIsInConflict', {}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorMilitiaMax",
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "are militia units in <u(sector_id)> of max count and upgrade",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "are militia units in <u(sector_id)> not of max count and upgrade",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			local sector = gv_Sectors[sector_id]
			local militia_squad_id = sector.militia_squad_id 
			if not militia_squad_id then return false end
			
			local militia_squad = gv_Squads[militia_squad_id]
			if #(militia_squad.units or "") < sector.MaxMilitia then return false end	
			
			local ud = GetLeastExpMilitia(militia_squad.units)
			local least_exp_templ = ud and ud.class
			return ud and ud.class == MilitiaUpgradePath[#MilitiaUpgradePath]
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if militia units in <u(sector_id)> are of max count and upgrade",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorMilitiaMax', {
			Negate = true,
			sector_id = "I3",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorMilitiaNumber",
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('PropertyDefCombo', {
		'category', "General",
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to the specified militia number.",
		'default', ">",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
		'min', 0,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "are militia units in <u(sector_id)> sector <u(Condition)> <Amount>",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return self:CompareOp(GetSectorMilitiaCount(sector_id))
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks militia units count in sector",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorMilitiaNumber', {
			Amount = 5,
			sector_id = "I3",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "SectorWarningReceived",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "sector_id",
		'name', "Sector Id",
		'help', "Sector id.",
		'default', "current",
		'items', function (self) return table.iappend({{text="current",value="current"}}, GetCampaignSectorsCombo()) end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If <u(sector_id)> sector's warning state has been triggered.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If <u(sector_id)> sector's warning state has NOT been triggered.",
		'untranslated', true,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector_id = self.sector_id == "current" and gv_CurrentSectorId or self.sector_id
			return gv_Sectors[sector_id] and gv_Sectors[sector_id].warningReceived
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the current or specified sector has had its warning state triggered.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SectorCheckCity', {
			sector_id = "H2",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Sectors",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"BanterFunctionObjectBase",
	},
	group = "Conditions",
	id = "SetpieceIsTestMode",
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if a set-piece is currently playing in test mode.",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return IsSetpieceTestMode()
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If a set-piece playing in test mode",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If a set-piece NOT playing in test mode",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Interactions",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SetpieceIsTestMode', {}),
	}),
})

PlaceObj('ConditionDef', {
	id = "SquadDefeated",
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Check if <u(custom_squad_id)> squad is defeated",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if specified squad is defeated",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local squad_id = gv_CustomQuestIdToSquadId[self.custom_squad_id]
			return squad_id and not gv_Squads[squad_id]
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.custom_squad_id then
				return "Specify Custom Squad Id"
			end
		end,
	}),
	PlaceObj('PropertyDefText', {
		'id', "custom_squad_id",
		'name', "Custom Squad Id",
		'help', "Custom squad ID.",
		'translate', false,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('SquadDefeated', {
			custom_squad_id = "Buns",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "UnitApproachedBy",
	PlaceObj('PropertyDefCombo', {
		'id', "Unit",
		'name', "Unit",
		'help', "The approaching unit to check for.",
		'items', function (self) return GetTargetUnitCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not context or not context.approachingUnits then return false end
			for i, u in ipairs(context.approachingUnits) do
				if UnitTarget.Match(nil, self.Unit, u)  then
					return true
				end
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if approached by '<u(Unit)>'",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', 'Checks if the unit which approached a unit which plays "approaching banters" is of a specified type.',
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Unit then
				return "No unit selected"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return self
		end,
		'TestObject', PlaceObj('UnitApproachedBy', {
			Unit = "Raven",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	id = "UnitCanGoToPos",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "PositionMarker",
		'name', "Position Marker",
		'items', function (self) return GridMarkerGroupsCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "marker, context",
		'code', function (self, marker, context)
			if gv_SatelliteView then return end
			return self:MatchMapUnits(marker, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, marker,context",
		'code', function (self, unit, marker,context)
			local markers = MapGetMarkers(false, self.PositionMarker)
			if not markers or #markers == 0 then
				return false
			end
			local pfclass = CalcPFClass(unit.CurrentSide, unit.stance, unit.body_type)
			local has_path, closest_pos = pf.HasPosPath(unit:GetPos(), markers, pfclass)
			-- markers sometimes are not placed accuratly on the passable grid
			if closest_pos then
				for i, marker in ipairs(markers) do
					local x, y, z = marker:GetPosXYZ()
					if closest_pos:Equal(x, y, z) then
						return true
					elseif closest_pos:Equal2D(x, y) then
						local z1 = z or terrain.GetHeight(x, y)
						local z2 = closest_pos:z() or terrain.GetHeight(closest_pos)
						if abs(z1 - z2) < const.SlabSizeZ then
							return true
						end
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' can go to <u(PositionMarker)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' CANNOT go to <u(PositionMarker)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a unit can go to a marker postion.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitCanGoToPos', {
			PositionMarker = "MainHyenasDoor",
			TargetUnit = "Butcher",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	id = "UnitHasInteraction",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "CombatAction",
		'name', "Interaction",
		'help', "The specific interaction that has to occur.",
		'preset_class', "CombatAction",
		'preset_group', "Interactions",
		'extra_item', "any",
		'default', "any",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Event",
		'help', "Which part of the interaction to check for. If set to false, any will be matched",
		'items', function (self) return InteractionLogEvents end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Result",
		'help', "The kind of interaction result you want to check for. If set to false, any will be matched",
		'items', function (self) return InteractionLogResults[self.CombatAction] end,
	}),
	PlaceObj('PropertyDefObject', {
		'id', "Interactable",
		'name', "Interactable",
		'help', "The interactable which is interacted with.",
		'base_class', "Interactable",
		'format_func', function (gameobj)
			   if gameobj and IsValid(gameobj) then
					local x, y = gameobj:GetPos():xy()
					local label = gameobj:HasMember("group") and gameobj.group or gameobj.class
					return string.format("%s xx:%d yy:%d", label, x, y)
				else
					return ""
				end
		end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Group",
		'name', "Group",
		'help', "Find all from group and check for interaction with any of them.",
		'default', "false",
		'items', function (self) return GetUnitGroups() end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "StoreAsTable",
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Test if an interaction has happened",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local interactables = self:ResolveInteractable()
			for _, interactable in ipairs(interactables) do
				local obj
				if IsKindOf(interactable, "Interactable") then
					obj = interactable
				else
					obj = ResolveInteractableObject(interactable)
				end
				if IsValid(obj) then
					for i, log in ipairs(obj.interaction_log) do
						local log_unit = g_Units[log.unit_template_id]
						local unit_matches = self:MatchMapUnits(log_unit, context)
						if not unit_matches then goto continue end
						
						if self.CombatAction ~= "any" then
							if self.CombatAction ~= log.action then goto continue end
						end
						
						if self.Event then
							if self.Event ~= log.event then goto continue end
						end
						
						if self.Result then
							if self.Result ~= log.result then goto continue end
						end
						
						if true then
							if context then context.target_units = { log_unit } end
							return true
						end
						
						::continue::
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "ResolveInteractable",
		'code', function (self)
			-- find all from group and check for interaction with any of them
			local group = self.Group
			return group and Groups and Groups[group] or self.Interactable and { self.Interactable }
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' interacted with '<Interactable.class>'",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(TargetUnit)> hasn't interacted with <Interactable.class>",
		'untranslated', true,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitHasInteraction', {
			'TargetUnit', "Buns",
			'CombatAction', "Interact_Disarm",
			'Group', "TrappedContainer_Alarm",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitHasPerk",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "HasPerk",
		'name', "Has perk",
		'help', "if the unit has the specified perk.",
		'preset_class', "CharacterEffectCompositeDef",
		'preset_filter', function (preset, obj, prop_meta)
			return preset.object_class == "Perk"
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' has perk <u(HasPerk)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if  '<u(TargetUnit)>' has not perk <u(HasPerk)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks a given perk for a unit",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.HasPerk then return false end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return HasPerk(unit, self.HasPerk)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.HasPerk then
				return "Please specify the perk"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitHasPerk', {
			HasPerk = "Ambidextrous",
			TargetUnit = "LegionRaider_WeakFlagHill",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	id = "UnitHasStat",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Stat",
		'name', "Unit Stat",
		'help', "Unit Properties stat.",
		'items', function (self) return GetUnitStatsCombo() end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Condition",
		'name', "condition",
		'help', "Select the relation to the specified value.",
		'default', ">=",
		'items', function (self) return { ">=", "<=", ">", "<", "==", "~=" } end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'name', "Amount",
		'help', "Set the value to check against.",
		'default', 0,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.Stat then return false end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj,context",
		'code', function (self, unit, obj,context)
			if not self.Stat then return false end
			if unit:IsDead() then return false end
			
			local stat = unit[self.Stat]
			local result = self:CompareOp(stat, context)
			local textContext = SubContext(unit, { stat = stat, threshold = self.Amount })
			
			context = context or empty_table
			if result and self.SuccessText and not context.no_log then
				CombatLog("important", T{self.SuccessText, textContext})
			end
			if not result and self.FailText and not context.no_log then
				CombatLog("important", T{self.FailText, textContext})
			end
			if not context.no_log then
				CombatLog("debug", "Skill check of " .. self.Amount .. " " .. self.Stat .. " by " .. (unit.unitdatadef_id or unit.class) .. " " .. tostring(result) .. " (" .. stat .. ")" )
			end
			
			return result
		end,
	}),
	PlaceObj('PropertyDefText', {
		'id', "SuccessText",
		'name', "SuccessText",
		'help', "Text to display in the log if the check succeeds.",
	}),
	PlaceObj('PropertyDefText', {
		'id', "FailText",
		'name', "FailText",
		'help', "Text to display in the log if the check fails.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>': <u(Stat)><u(Condition)><Amount>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if not (<u(TargetUnit)>: <u(Stat)><u(Condition)><Amount>)",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks a given stat for a merc",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Stat then
				return "Choose unit Stat to check!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitHasStat', {
			Amount = 50,
			Stat = "Mechanical",
			TargetUnit = "any merc",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitHasStatusEffect",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "Effect",
		'preset_class', "CharacterEffectCompositeDef",
		'preset_filter', function (preset, obj, prop_meta)
			return preset.object_class ~= "Perk"
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' has effect <u(Effect)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if  '<u(TargetUnit)>' does not have effect <u(Effect)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks a given perk for a unit",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.Effect then return false end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return unit:HasStatusEffect(self.Effect)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Effect then
				return "Please specify the effect"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitHasStatusEffect', {
			Effect = "Bleeding",
			TargetUnit = "any merc",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitHasWeaponKind",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "weaponKind",
		'name', "Weapon Kind",
		'items', function (self) return {"Unarmed", "ThrowableKnife", "MeleeWeapon", "AssaultRifle", "SubmachineGun", "Pistol", "Revolver", "Shotgun", "SniperRifle", "MachineGun", "HeavyWeapon", "Grenade"} end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If '<u(TargetUnit)>' has a <u(weaponKind)> equiped.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If '<u(TargetUnit)>' doesn't have a <u(weaponKind)>  equipped.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a unit has a specific Weapon Kind equipped.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.weaponKind then return false end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			local weapons, slots = unit:GetHandheldItems()
			if self.weaponKind == "Unarmed" then
				local emptyHandsA = true
				local emptyHandsB = true
				for _, slot in ipairs(slots) do
					if slot == "Handheld A" then
						emptyHandsA = false
					elseif slot == "Handheld B" then
						emptyHandsB = false
					end
				end
				return emptyHandsA or emptyHandsB
			end
			
			if self.weaponKind == "ThrowableKnife" then
				for _, weapon in ipairs(weapons) do
					if IsKindOf(weapon, "MeleeWeapon") and weapon.CanThrow then
						return true
					end
				end
				return false
			end
			
			for _, weapon in ipairs(weapons) do
				if IsKindOf(weapon, self.weaponKind) then
					return true
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.weaponKind then
				return "Please specify Weapon Kind"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitHasWeaponKind', {
			TargetUnit = "current unit",
			weaponKind = "Unarmed",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitHealth",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "UnitHealth",
		'name', "Unit Health",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' has HitPoints <= <UnitHealth>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' has HitPoints > <UnitHealth>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if the there's a unit within a given group whose current health is below, equal to or above a given value.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return unit.HitPoints <= self.UnitHealth
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.UnitHealth then
				return "Please specify unit health"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitHealth', {
			Negate = true,
			TargetUnit = "Vicki",
			UnitHealth = 78,
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitHireStatus",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Status",
		'name', "Hire Status",
		'help', "The hiring status of the merc.",
		'default', "Available",
		'items', function (self) return PresetGroupCombo("MercHireStatus", "Default") end,
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "TargetUnit",
		'name', "Target Unit",
		'help', "Target unit for match.",
		'items', function (self) return GetTargetUnitCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.Status then return false end
			if not self.TargetUnit then return false end
				
			local unit = UnitDataDefs[self.TargetUnit]
			local unitData = gv_UnitData[unit.id]
			local stat = unitData and unitData.HireStatus or "Available"
			if self.Status ~= "Hired" and not unitData.MessengerOnline then return false end
			return stat == self.Status
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is of the <u(Status)> status.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' isn't of the <u(Status)> status.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "If the unit matches the set hiring status. If the merc is offline, this returns false",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Status then
				return "Choose unit hiring status to check!"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitHireStatus', {
			Status = "Hired",
			TargetUnit = "Buns",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsAroundMarkerOfGroup",
	PlaceObj('PropertyDefCombo', {
		'id', "MarkerGroup",
		'name', "MarkerGroup",
		'help', "Marker group to match",
		'items', function (self) return GridMarkerGroupsCombo() end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then
				return false
			end
			local group = self.MarkerGroup
			if (group or "") ~= "" and not Groups[group] then
				return false
			end
			local units1 = self:GetMatchedMapUnits(self.TargetUnit, context)
			if not units1 or #units1 == 0 then
				return false
			end
			local markers = MapGetMarkers(false, group)
			for i, m in ipairs(markers) do
				for i, u in ipairs(units1) do
					local vx, vy, vz = WorldToVoxel(u)
					if m:IsVoxelInsideArea(vx, vy, vz) then
						if type(context) == "table" then
							context.target_units = { u }
						end
						return true
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is inside a '<u(MarkerGroup)>' marker",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is not inside a '<u(MarkerGroup)>' marker",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check is a unit is inside the area of a marker from a specified group",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TargetUnit or not self.MarkerGroup then
				return "Specify the target unit and marker"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return self
		end,
		'TestObject', PlaceObj('UnitIsAroundMarkerOfGroup', {
			MarkerGroup = "BannerPlaza",
			Negate = true,
			TargetUnit = "any merc",
		}),
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsAroundOtherUnit",
	PlaceObj('PropertyDefCombo', {
		'id', "SecondTargetUnit",
		'name', "SecondTargetUnit",
		'help', "Second unit or group for match.",
		'items', function (self) return GetTargetUnitCombo() end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Distance",
		'name', "Distance",
		'help', "The distance between the two units in meters.",
		'default', 20,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then
				return false
			end
			local units1 = self:GetMatchedMapUnits(self.TargetUnit, context)
			if not units1 then
				return false
			end
			local units2 = self:GetMatchedMapUnits(self.SecondTargetUnit, context)
			if not units2 then
				return false
			end
			local units2_around_units1
			local dist = self.Distance * guim
			for _, u2 in ipairs(units2) do
				for _, u1 in ipairs(units1) do
					if IsCloser2D(u1, u2, dist) then
						if not units2_around_units1 then units2_around_units1 = {} end
						units2_around_units1[u2] = true
						break
					end
				end
			end
			if not units2_around_units1 then
				return false
			end
			if type(context) == "table" then
				units2_around_units1 = table.keys2(units2_around_units1)
				table.sortby_field(units2_around_units1, "handle")
				context.target_units = units2_around_units1
			end
			return true
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is around '<u(SecondTargetUnit)>'",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a unit is around another unit.\nThe second unit can be someone particular or a group.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TargetUnit or not self.SecondTargetUnit then
				return "Specify the target units"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return self
		end,
		'TestObject', PlaceObj('UnitIsAroundOtherUnit', {
			SecondTargetUnit = "FlagHill_Raider_Jose",
			TargetUnit = "any merc",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsAware",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Pending",
		'help', "Also pass the check if the unit is currently waiting to become aware",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is aware",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if  '<u(TargetUnit)>' is not aware",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks unit for the Unaware status effect.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then return end
			return self:MatchMapUnits(obj or {}, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return unit:IsAware(self.Pending)
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitIsAware', {
			TargetUnit = "Raiders",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsCombatTurn",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is part of the currently active team in combat",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if  '<u(TargetUnit)>' is not part of the currently active team in combat",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if it's unit's turn in combat",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:MatchMapUnits(obj or {}, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return IsInCombat() and g_Teams[g_CurrentTeam]  == obj.team
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitIsCombatTurn', {
			TargetUnit = "any merc",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsInSector",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local sector = self.Sector
			if sector == "current" then
				sector = gv_CurrentSectorId
			end
			local unit = self.TargetUnit
			local squads = GetUngroupedSquadsInSector(sector)
			for i, s in ipairs(squads) do
				for i, u in ipairs(s.units) do
					if self:Match(unit, gv_UnitData[u]) then return true end
				end
			end
			
			return false
		end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Sector",
		'name', "Sector",
		'help', "The sector to check in.",
		'items', function (self) return GetCampaignSectorsCombo("current") end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetEditorView",
		'code', function (self)
			local sectors = GetCampaignSectorsCombo("current")
			local data = table.find_value(sectors, "value", self.Sector)
			local name =  data.text
			if self.Negate then
				return T{451396610003, "if '<u(TargetUnit)>' is NOT on the map <u(name)>.", name =  name }
			else
				return T{625324726787, "if '<u(TargetUnit)>' is on the map <u(name)>.", name =  name}
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a specific merc is  in a specific sector. Does not work for NPC or units that are not in a squad.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TargetUnit then
				return "Specify the target unit"
			end
			if not self.Sector then
				return "Specify a sector"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'TestObject', PlaceObj('UnitIsInSector', {
			Sector = "A8",
			TargetUnit = "Vicki",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsMerc",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is a merc",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if  '<u(TargetUnit)>' is not a merc",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if unit is a merc",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:MatchMapUnits(obj or {}, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return unit:IsMerc()
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitIsMerc', {
			TargetUnit = "any merc",
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	id = "UnitIsNearbyArea",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "marker, context",
		'code', function (self, marker, context)
			if gv_SatelliteView then return end
			return self:MatchMapUnits(marker, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, marker,context",
		'code', function (self, unit, marker,context)
			local obj = context and context.interactable or marker
			return obj and obj:IsInsideArea(unit) or false
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "TestInGed",
		'params', "subject, ged, context",
		'code', function (self, subject, ged, context)
			-- Find marker in selected collection and pass it down when testing from GED
			local selObj = selo()
			if selObj then
				local root_collection = selObj:GetRootCollection()
				local collection_idx = root_collection and root_collection.Index or 0
				local marker = MapGetFirst("map", "collection", collection_idx, true, "GridMarker")
				if marker then context = { interactable = marker } end
			end
			
			return FunctionObject.TestInGed(self, subject, ged, context)
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is inside marker area",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if <u(TargetUnit)> merc is outside marker area",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a merc is inside a marker area.\nThe merc can be someone particular or just any merc.",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return selo()
		end,
		'TestObject', PlaceObj('UnitIsNearbyArea', {
			TargetUnit = "FlagHill_Corazon",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitIsOnMap",
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if gv_SatelliteView then return end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj,context",
		'code', function (self, unit, obj,context)
			return unit and not unit:IsDead()
		end,
	}),
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is on the map and alive.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' is not on the map.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if a specific unit is on the map.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.TargetUnit then
				return "Specify the target unit"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return self
		end,
		'TestObject', PlaceObj('UnitIsOnMap', {
			TargetUnit = "Mouse",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	id = "UnitSquadHasItem",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "ItemId",
		'name', "Item",
		'help', "Item id that is looked for.",
		'preset_class', "InventoryItemCompositeDef",
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Amount",
		'name', "Amount",
		'help', "Amount of that item.",
		'default', 1,
		'min', 1,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if merc(s) have <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if merc(s) haven't <u(ItemId)>(<Amount>) ",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "if the item is in the inventory of any merc on the map",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return  HasItemInSquad("all_squads", self.ItemId, self.Amount)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.ItemId then
				return "Set Item!"
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('UnitSquadHasItem', {
			ItemId = "US_Passport",
		}),
	}),
})

PlaceObj('ConditionDef', {
	id = "UnitSquadHasMerc",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "Name",
		'help', "Look for a merc with the specified name.",
		'items', function (self) return MercPresetCombo() end,
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "HasPerk",
		'name', "Has perk",
		'help', "Look for a merc that has the specified perk.",
		'preset_class', "CharacterEffectCompositeDef",
		'preset_filter', function (preset, obj, prop_meta)
			return preset.object_class == "Perk"
		end,
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "HasStat",
		'name', "Has stat",
		'help', "Look for a merc with a value of this stat above a threshold.",
		'items', function (self) return GetUnitStatsCombo end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "StatValue",
		'name', "Stat value",
		'help', "Look for a merc with at least this value of the stat in 'Has stat'.",
		'extra_code', "no_edit = function(obj) return not obj.HasStat end",
		'slider', true,
		'min', 1,
		'max', 100,
	}),
	PlaceObj('PropertyDefText', {
		'id', "BestUnitFound",
		'name', "BestUnitFound",
		'help', "Best unit found in eval to display in UI auto generated texts.",
		'dont_save', true,
		'read_only', true,
		'no_edit', true,
		'translate', false,
	}),
	PlaceObj('PropertyDefText', {
		'id', "MaxStatUnitFound",
		'name', "MaxStatUnitFound",
		'help', "The unit with the max stat found in eval to display in UI auto generated texts.",
		'dont_save', true,
		'read_only', true,
		'no_edit', true,
		'translate', false,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "Find merc <opt(u(Name),u('named '),' ')><opt(u(HasPerk),u('with perk '),' ')><opt(StatValue, u('with min '), ' ')><opt(u(HasStat), '', ' ')> on the map.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "Find NO merc <opt(u(Name),u('named '),' ')><opt(u(HasPerk),u('with perk '),' ')><opt(StatValue, u('with min '), ' ')><opt(u(HasStat), '', ' ')> on the map.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Looks for a merc on the map according to name, perks, or a stat value. Succeeds if such a merc is found, storing it in the 'found_merc' field of the context table.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local stat, max_idx, max_stat, found_idx, found_stat, found_equal, found_neg
			local name = self.Name
			local has_stat = self.HasStat
			local has_perk = self.HasPerk
			local stat_value = self.StatValue
			local negative = rawget(self, "Negate") --rawget gets around the Ged warning for accessing Negate in __eval
			local units = GetAllPlayerUnitsOnMap()
			for idx, unit in ipairs(units) do
				if not unit:IsDead() then
					if has_stat then
						stat = unit[has_stat]
						if not max_stat or stat >= max_stat then
							max_idx = idx
							max_stat = stat
						end
					end
					if (not name or name == unit.session_id) and (not has_stat or stat >= stat_value) and (not has_perk or HasPerk(unit, has_perk)) then
						if negative then
							found_neg = true
						else
							if not has_stat or not found_stat or stat > found_stat then
								found_idx = idx
								found_stat = stat
								found_equal = 1
							elseif stat == found_stat then
								found_equal = found_equal + 1
								if BraidRandom(xxhash(unit.session_id, stat), 1000) * found_equal < 1000 then
									found_idx = idx
									found_stat = stat
								end
							end
						end
					else
						if negative then
							if not has_stat or not found_stat or stat < found_stat then
								found_idx = idx
								found_stat = stat
								found_equal = 1
							elseif stat == found_stat then
								found_equal = found_equal + 1
								if BraidRandom(xxhash(unit.session_id, stat), 1000) * found_equal < 1000 then
									found_idx = idx
									found_stat = stat
								end
							end	
						end
					end
				end
			end
			if found_idx and type(context) == "table" and not context.found_merc then
				context.found_merc = units[found_idx].session_id
			end
			self.BestUnitFound = found_idx and units[found_idx].session_id or "not found"
			self.MaxStatUnitFound = max_idx and units[max_idx].session_id or "not found"
			if negative then
				return found_neg or false
			elseif found_idx then
				return true
			end
			return false
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.Name and not self.HasPerk and not self.HasStat then
				return "Please specify at least one of 'Name', 'Has perk' or 'Has stat'."
			end
			if self.HasStat and not self.StatValue then
				return "Please specify 'Stat value'."
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetUIText",
		'params', "context, template, game",
		'code', function (self, context, template, game)
			local merc, merc_name
			if self.BestUnitFound then
				if self.BestUnitFound =="not found" then
				else
					merc = gv_UnitData and gv_UnitData[self.BestUnitFound]
					merc_name = merc and merc.Nick
				end	
			end
			if not game then 
				merc_name = Untranslated("[MercName]")
			end
			
			if self.Name and merc_name then
				if template then
					return T{template, MercName = merc_name}
				elseif not rawget(self, "Negate") then
					return T{250357174120, "<MercName> has something to say", MercName = merc_name}
				end	
			end
			
			if gv_UnitData and self.HasStat and merc_name then
				merc = not gv_SatelliteView and g_Units[self.MaxStatUnitFound] or gv_UnitData[self.MaxStatUnitFound]
				merc_name = merc and merc.Nick 
				if not game then 
					merc_name = Untranslated("[MercName]")
				end
				local prop_meta = table.find_value(UnitPropertiesStats:GetProperties(), "id", self.HasStat)
				local stat = const.TagLookupTable[string.lower(prop_meta.id)] or  T{638710586683, "<em><name></em>", name = prop_meta.name}
				local stat_val = merc and merc[self.HasStat] or Untranslated("[MaxStatValue]")
				if template then
					return T{template, MercName = merc_name, Stat = stat, StatVal = stat_val}
				else
					return T{410073687100, "<Stat> check: <em><MercName></em> has the highest stat (<StatVal>)", MercName = merc_name, Stat = stat, StatVal = stat_val}
				end
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetPhraseTopRolloverText",
		'params', "negative, template, game",
		'code', function (self, negative, template, game)
			local merc_name, merc	
			if self.BestUnitFound then
				if self.BestUnitFound =="not found" then
				else
					merc = gv_UnitData[self.BestUnitFound]
					merc_name = merc and merc.Nick
				end	
			end
			if not game then 
				merc_name = Untranslated("[MercName]")
			end
			if  self.HasStat  then
				local prop_meta = table.find_value(UnitPropertiesStats:GetProperties(), "id", self.HasStat)
				local stat = const.TagLookupTable[string.lower(prop_meta.id)] or T{638710586683, "<em><name></em>", name = prop_meta.name}
				if (merc or editor) and not self.Negate then
					if template then
						return T{template, MercName = merc_name, Stat = stat}
					else
						return T{351828405210, "<Stat> check successful", MercName = merc_name, Stat = stat}
					end
				elseif (not merc or editor)and self.Negate then
						return T{786464738039, "<Stat> check failed", MercName = merc_name, Stat = stat}
				end
			end
			if  self.HasPerk and merc_name and not self.Negate then			
				local preset =  CharacterEffectDefs[self.HasPerk]
				local perk = const.TagLookupTable[string.lower(self.HasPerk)] or T{638710586683, "<em><name></em>", name = preset.DisplayName}
				if template then
					return T{template, MercName = merc_name, Perk = perk}
				elseif self.HasPerk then
					return T{346878086135, "<Perk> perk activated (<em><MercName></em>)", MercName = merc_name, Perk = perk}
				end	
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetPhraseFX",
		'code', function (self)
			if self.HasStat then
				return "ConversationStatCheck"
			end
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "OnEditorSetProperty",
		'params', "prop_id, old_value, ged",
		'code', function (self, prop_id, old_value, ged)
			if prop_id == "HasStat" and not self.HasStat then
				self.StatValue = false
			end
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitSquadHasMerc', {
			HasStat = "Wisdom",
			Negate = true,
			StatValue = 100,
		}),
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitStatusEffect",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefPresetId', {
		'id', "HasStatusEffect",
		'name', "HasStatusEffect",
		'help', "if the unit has the specified status effect.",
		'preset_class', "CharacterEffectCompositeDef",
		'preset_filter', function (preset, obj, prop_meta)
			return preset.object_class ~= "Perk"
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' has status effect <u(HasStatusEffect)> (<Stacks>)",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' does NOT have status effect <u(HasStatusEffect)> (<Stacks>)",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks a given status effect for a unit",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not self.HasStatusEffect then return false end
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			local eff = unit:GetStatusEffect(self.HasStatusEffect)
			return eff and eff.stacks >= self.Stacks
		end,
	}),
	PlaceObj('PropertyDefNumber', {
		'id', "Stacks",
		'default', 1,
		'min', 1,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "GetError",
		'code', function (self)
			if not self.HasStatusEffect then
				return "Please specify the status effect"
			end
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitStatusEffect', {
			HasStatusEffect = "Hidden",
			TargetUnit = "Vicki",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	DefParentClassList = {
		"Condition",
		"UnitTarget",
	},
	group = "Conditions",
	id = "UnitTiredness",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefChoice', {
		'id', "TirednessLevel",
		'default', 0,
		'items', function (self) return UnitTirednessComboItems end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(TargetUnit)>' tiredness level is higher than <tiredness(TirednessLevel)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(TargetUnit)>' tiredness level is lower than <tiredness(TirednessLevel)>",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Checks if tiredness level for a unit is above/below the specified value. Units with Tiredness matching the condition value will fail the test.",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			return self:MatchMapUnits(obj, context)
		end,
	}),
	PlaceObj('ClassMethodDef', {
		'name', "UnitCheck",
		'params', "unit, obj, context",
		'code', function (self, unit, obj, context)
			return unit.Tiredness > self.TirednessLevel
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self)
			return SelectedObj
		end,
		'TestObject', PlaceObj('UnitTiredness', {
			TargetUnit = "any merc",
		}),
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Units",
	}),
})

PlaceObj('ConditionDef', {
	id = "VillainIsDefeated",
	PlaceObj('PropertyDefBool', {
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefCombo', {
		'id', "Group",
		'name', "Group",
		'help', "",
		'default', "false",
		'items', function (self) return GetUnitGroups() end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "if '<u(Group)>' is defeated",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "if '<u(Group)>' is not defeated",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if selected villain is defeated",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			if not Groups or not Groups[self.Group] then
				-- nothing spawned in this group yet
				return false
			end
			for _, obj in ipairs(Groups[self.Group]) do
				if IsKindOf(obj, "Unit") then
					if obj:IsDefeatedVillain() then
						return true
					end
				end
			end
			return false
		end,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Player",
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if selected villain is defeated",
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('VillainIsDefeated', {
			Group = "CorazonSantiago",
		}),
	}),
})

PlaceObj('ConditionDef', {
	group = "Conditions",
	id = "WoundedMercs",
	PlaceObj('PropertyDefBool', {
		'category', "General",
		'id', "Negate",
		'name', "Negate Condition",
		'help', "If true, checks for the opposite condition.",
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "woundedMercs",
		'name', "Wounded Mercs",
		'help', "How many mercs should be wounded.",
		'default', 1,
	}),
	PlaceObj('PropertyDefNumber', {
		'category', "General",
		'id', "minWounds",
		'name', "Minimum Wounds",
		'help', "Minimum amount of wounds a merc should have in order to count.",
		'default', 1,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorView",
		'type', "text",
		'value', "If there are at least <woundedMercs> wounded Mercs with <minWounds> or more wounds.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorViewNeg",
		'type', "text",
		'value', "If there are LESS than <woundedMercs> wounded Mercs with <minWounds> or more wounds.",
		'untranslated', true,
	}),
	PlaceObj('ClassConstDef', {
		'name', "Documentation",
		'type', "text",
		'value', "Check if a set amount of mercs are wounded. And have a set amount of wounds.",
	}),
	PlaceObj('ClassConstDef', {
		'name', "EditorNestedObjCategory",
		'type', "text",
		'value', "Mercs",
	}),
	PlaceObj('ClassMethodDef', {
		'name', "__eval",
		'params', "obj, context",
		'code', function (self, obj, context)
			local woundedMercs = 0
			
			if gv_SatelliteView then
				for _, squad in ipairs(g_SquadsArray) do
					if squad.Side == "player1" then
						for i, u in ipairs(squad.units or empty_table) do
							local unit = gv_UnitData[u]
							local effect = unit:GetStatusEffect("Wounded")
							if effect and effect.stacks >= self.minWounds then
								woundedMercs = woundedMercs + 1
							end
						end
					end
				end
			else
				for _, unit in ipairs(g_Units) do
					local squad = unit:GetSatelliteSquad()
					if squad and squad.Side == "player1" then
						local effect = unit:GetStatusEffect("Wounded")
						if effect and effect.stacks >= self.minWounds then
							woundedMercs = woundedMercs + 1
						end
					end
				end
			end
			
			return woundedMercs >= self.woundedMercs
		end,
	}),
	PlaceObj('TestHarness', {
		'name', "TestHarness",
		'TestedOnce', true,
		'Tested', true,
		'GetTestSubject', function (self) return SelectedObj end,
		'TestObject', PlaceObj('WoundedMercs', {
			minWounds = 2,
			woundedMercs = 2,
		}),
	}),
})